C/math.h

C
← Volver a locale.h	math.h	Seguir con setjmp.h →

Este ficheiro de cabeceira foi deseñado para realizar as tarefas matemáticas básicas. A meirande parte das funcións requiren do uso de tipos reais. Pode incluírse nun código fonte mediante a seguinte directriz:

#include <math.h>

Funcións

Os ángulos exprésanse en radiáns. Todas as funcións traballan con tipos double, salvo que se indique o contrario. Para traballar con tipos float sufíxase o identificador da función cun «f», e para traballar con tipos long double sufízase cun «l».

acos

Esta función devolve o coseno inverso en radiáns. O argumento debería ter un valor entre -1 e 1, e o valor devolto terá un valor entre 0 e π. Estes son os prototipos desta función (para os distintos tipos reais):

float acosf(float x);
double acos(double x);
long double acosl(long double x);

acosh

Coseno inverso hiperbólico. Estes son os prototipos desta función (para os distintos tipos reais):

float acoshf(float x);
double acosh(double x); 
long double acoshl(long double x);

asin

Esta función devolve o seno inverso en radiáns. O argumento debería ter un valor entre -1 e 1, e o valor devolto terá un valor entre -π/2 e π/2. Estes son os prototipos desta función (para os distintos tipos reais):

float asinf(float x);
double asin(double x);
long double asinl(long double x);

asinh

Seno inverso hiperbólico. Estes son os prototipos desta función (para os distintos tipos reais):

float asinhf(float x);
double asinh(double x); 
long double asinhl(long double x);

atan

Esta función devolve a tanxente inversa do seu argumento. O valor devolto terá un valor entre -π/2 e π/2. Estes son os prototipos desta función (para os distintos tipos reais):

float atanf(float x);
double atan(double x);
long double atanl(long double x);

atan2

Esta función devolve a tanxente inversa do cociente entre o seu primeiro e o seu segundo argumento. O valor devolto terá un valor entre -π e π. Podería producirse un erro de ser cero o valor de ambos os dous argumentos. Estes son os prototipos desta función (para os distintos tipos reais):

float atan2f(float y, float x);
double atan2(double y, double x);
long double atan2l(long double y, long double x);

atanh

Tanxente inversa hiperbólica. Estes son os prototipos desta función (para os distintos tipos reais):

float atanhf(float x);
double atanh(double x); 
long double atanhl(long double x);

cbrt

cbrt(x) devolve a raíz cúbica de x. Estes son os prototipos desta función (para os distintos tipos reais):

float cbrtf(float x);
double cbrt(double x);
long double cbrtl(long double x);

ceil

Redondeo cara arriba, calcular o menor enteiro maior que o parámetro. Estes son os prototipos desta función (para os distintos tipos reais):

float ceilf(float x);
double ceil(double x);
long double ceill(long double x);

copysign

copysign(x, y) devolve o valor de x co signo de y.

cos

Devolve o coseno en radiáns. Estes son os prototipos desta función (para os distintos tipos reais):

float cosf(float x);
double cos(double x);
long double cosl(long double x);

cosh

Devolve o coseno hiperbólico. Pode ocorrer un erro se o valor do argumento é grande de máis, ou se é menor que un. Estes son os prototipos desta función (para os distintos tipos reais):

float coshf(float x);
double cosh(double x); 
long double coshl(long double x);

erf

Función de erro. Estes son os prototipos desta función (para os distintos tipos reais):

float erff(float x);
double erf(double x);
long double erfl(long double x);

erfc

Función de erro complementaria. Estes son os prototipos desta función (para os distintos tipos reais):

float erfcf(float x);
double erfc(double x);
long double erfcl(long double x);

exp

Función exponencial. Pode haber un erro se a magnitude do argumento é demasiado grande. Estes son os prototipos desta función (para os distintos tipos reais):

float expf(float x);
double exp(double x);
long double expl(long double x);

exp2

exp2(x) eleva 2 ao expoñente x, «2^x». Pode haber un erro se a magnitude do argumento é demasiado grande. Estes son os prototipos desta función (para os distintos tipos reais):

float exp2f(float x);
double exp2(double x);
long double exp2l(long double x);

expm1

Un menos que o exponencial de x, «e^x-1». Pode haber un erro se a magnitude do argumento é demasiado grande. Estes son os prototipos desta función (para os distintos tipos reais):

float expm1f(float x);
double expm1(double x);
long double expm1l(long double x);

fabs

Valor absoluto (dun número real). Estes son os prototipos desta función (para os distintos tipos reais):

float fabsf(float x);
double fabs(double x); 
long double fabsl(long double x);

fdim

fdim(x, y) devolve a diferencia positiva entre x e y. É equivalente a «fmax(x-y, 0)».

floor

Redondeo cara abaixo, calcular o maior enteiro menor que o parámetro. Estes son os prototipos desta función (para os distintos tipos reais):

float floorf(float x);
double floor(double x);
long double floorl(long double x);

fma

fma(x, y, z) devolve o valor de «(x * y) + z». É o que se coñece coma “multiplicar e engadir”.

fmax

fmax(x, y) devolve o valor máximo, x ou y.

fmin

fmin(x, y) devolve o valor mínimo, x ou y.

fmod

Resto (dunha división de números reais). Estes son os prototipos desta función (para os distintos tipos reais):

float fmodf(float x, float y);
double fmod(double x, double y);
long double fmodl(long double x, long double y);

frexp

frexp(x, p) separa a mantisa e mailo expoñente de x, gardando o expoñente na variable de tipo <sourc lang=c enclose=none>int</source> á que apunta p e devolvendo o valor da mantisa. É dicir, o valor devolto equivale ao valor orixinal coa parte do expoñente a cero. Estes son os prototipos desta función (para os distintos tipos reais):

float frexpf(float value, int *ex);
double frexp(double value, int *ex);
long double frexpl(long double value, int *ex);

hypot

hypot(x, y) devolve a hipotenusa de x e y. Estes son os prototipos desta función (para os distintos tipos reais):

float hypotf(float x, float y);
double hypot(double x, double y);
long double hypotl(long double x, long double y);

ilogb

ilogb(x) extrae o expoñente de x e o devolve como signed int. Se x vale cero, a función devolve a clave FP_ILOGB0. Se x vale infinito, a función devolve a clave INT_MAX. Se x é “NaN” (Not A Number, «non é un número»), a función devolve a clave FP_ILOGBNAN. En calquera outro caso, a función equivale a chamar á función logb correspondente e devolver o valor como int. Podería haber un erro de superación dos límites se x vale cero. As claves FP_ILOGB0 e FP_ILOGBNAN están definidas en math.h, e INT_MAX en limits.h.

Estes son os prototipos desta función (para os distintos tipos reais):

int ilogbf(float x);
int ilogb(double x);
int double ilogbl(long double x);

ldexp

ldexp(x, y) multiplica o número real x por unha potencia y (de tipo int) de 2 e devolve o resultado. Noutras palabras, devolve unha copia de x co seu expoñente aumentado en y. Pode haber un erro por superación dos límites do tipo. Estes son os prototipos desta función (para os distintos tipos reais):

float ldexpf(float x, int ex);
double ldexp(double x, int ex);
long double ldexpl(long double x, int ex);

lgamma

Logaritmo natural do valor absoluto da función gamma. Estes son os prototipos desta función (para os distintos tipos reais):

float lgammaf(float x);
double lgamma(double x);
long double lgammal(long double x);

llint

Redondear a un enteiro co método actual. Devolve o valor co tipo long long int. Estes son os prototipos desta función (para os distintos tipos reais):

long long int llrintf(float x);
long long int llrint(double x);
long long int llrintl(long double x);

llround

Redondear a un enteiro. Devolve o valor co tipo long long int. Estes son os prototipos desta función (para os distintos tipos reais):

long long int llroundf(float x);
long long int llround(double x);
long long int llroundl(long double x);

log

Devolve o logaritmo natural do seu argumento. Pode haber un erro se o número é negativo, e tamén pode haber un erro de número fóra dos límites se o argumento é cero. Estes son os prototipos desta función (para os distintos tipos reais):

float logf(float x);
double log(double x);
long double logl(long double x);

log10

Devolve o logaritmo en base 10 do seu argumento. Pode haber un erro se o número é negativo, e tamén pode haber un erro de número fóra dos límites se o argumento é cero. Estes son os prototipos desta función (para os distintos tipos reais):

float log10f(float x);
double log10(double x);
long double log10l(long double x);

log1p

log1p(x) devolve o logaritmo natural de «x + 1». Pode haber un erro se o número é inferior a -1, e tamén pode haber un erro de número fóra dos límites se o argumento é -1. Estes son os prototipos desta función (para os distintos tipos reais):

float log1pf(float x);
double log1p(double x);
long double log1pl(long double x);

log2

Devolve o logaritmo en base 2 do argumento. Pode haber un erro se o número é negativo, e tamén pode haber un erro de número fóra dos límites se o argumento é cero. Estes son os prototipos desta función (para os distintos tipos reais):

float log2f(float x);
double log2(double x);
long double log2l(long double x);

logb

logb(x) extrae o expoñente de x e o devolve coma int en coma flotante. Se x é “subnormal”, trátase coma se estivese normalizado. Estes son os prototipos desta función (para os distintos tipos reais):

float logbf(float x);
double logb(double x);
long double logbl(long double x);

lrint

Redondear a un enteiro co método actual. Devolve o valor co tipo long int. Estes son os prototipos desta función (para os distintos tipos reais):

long int lrintf(float x);
long int lrint(double x);
long int lrintl(long double x);

lround

Redondear a un enteiro. Devolve o valor co tipo long int. Estes son os prototipos desta función (para os distintos tipos reais):

long int lroundf(float x);
long int lround(double x);
long int lroundl(long double x);

modf

modf(x, p) divide o valor de x nas súas partes fraccionaria e enteira, cada unha delas co mesmo signo que x. Devolve a parte fraccionaria e almacena a parte enteira no apuntado polo punteiro p. Estes son os prototipos desta función (para os distintos tipos reais):

float modff(float value, float *iptr);
double modf(double value, double *iptr); 
long double modfl(long double value, long double *iptr);

nan

nan(s) devolve un “NaN” (Not A Number, «non é un número»), coa posibilidade de que o argumento sexa unha cadea de caracteres.

nearbyint

Redondear utilizando a dirección de redondeo actual e sen aplicar a excepción de inexactitude de coma flotante. Estes son os prototipos desta función (para os distintos tipos reais):

float nearbyintf(float x);
double nearbyint(double x);
long double nearbyintl(long double x);

nextafter

nextafter(x, y) devolve o seguinte valor representable despois de x (cara y)

nexttoward

Idéntico a pow(x, y), coa diferencia de que y é sempre de tipo long double.

pow

pow(x, y) eleva x a y, «xy». Pode ocorrer un erro se x é negativo e y non é un valor integral, ou se o resultado non pode representarse cando x vale cero e y é cero ou menor. Asemade, podería ocorrer algún erro relativo á superación de límites.

Estes son os prototipos desta función (para os distintos tipos reais):

float powf(float x, float y);
double pow(double x, double y);
long double powl(long double x, long double y);

remainder

remainder(x, y) calcula o resto da división entre ambos parámetros. Estes son os prototipos desta función (para os distintos tipos reais):

float remainderf(float x, float y);
double remainder(double x, double y);
long double remainderl(long double x, long double y);

remquo

remquo(x, y, p) actúa igual que remainder(x, y), salvo porque ademais almacena o cociente onde apunta o punteiro como int. Estes son os prototipos desta función (para os distintos tipos reais):

float remquof(float x, float y, int *quo);
double remquo(double x, double y, int *quo);
long double remquol(long double x, long double y, int *quo);

rint

Redondear a un enteiro utilizando o modo de redondeo actual e aplicando a excepción de inexactitude de coma flotante se o valor a devolver é distinto do valor do argumento. Estes son os prototipos desta función (para os distintos tipos reais):

float rintf(float x);
double rint(double x);
long double rintl(long double x);

round

Redondear a un enteiro, redondeando os casos intermedios en dirección oposta ao cero. Estes son os prototipos desta función (para os distintos tipos reais):

float roundf(float x);
double round(double x);
long double roundl(long double x);

scalbln

scalbln(x, n) equivale a «x × FLT_RADIX n>», onde n é de tipo long int. FLT_RADIX é a base do sistema de coma flotante (que utilizan os números reais en informática), e en caso de ser 2 o resultado é o mesmo que o de ldexp. Estes son os prototipos desta función (para os distintos tipos reais):

float scalblnf(float x, long int ex);
double scalbln(double x, long int ex);
long double scalblnl(long double x, long int ex);

scalbn

scalbln(x, n) equivale a «x × FLT_RADIX n>», onde n é de tipo int. FLT_RADIX é a base do sistema de coma flotante (que utilizan os números reais en informática), e en caso de ser 2 o resultado é o mesmo que o de ldexp. Estes son os prototipos desta función (para os distintos tipos reais):

float scalbnf(float x, int ex);
double scalbn(double x, int ex);
long double scalbnl(long double x, int ex);

sin

Devolve o seno en radiáns. Estes son os prototipos desta función (para os distintos tipos reais):

float sinf(float x);
double sin(double x);
long double sinl(long double x);

sinh

Devolve o seno hiperbólico. Pode ocorrer un erro se o valor do argumento é grande de máis. Estes son os prototipos desta función (para os distintos tipos reais):

float sinhf(float x);
double sinh(double x); 
long double sinhl(long double x);

sqrt

sqrt(x) devolve a raíz cadrada non negativa de <code>x</code>. Se o argumento é negativo producirase un erro. Estes son os prototipos desta función (para os distintos tipos reais): <source lang=c> float sqrtf(float x); double sqrt(double x); long double sqrtl(long double x);

tan

Devolve a tanxente en radiáns. Estes son os prototipos desta función (para os distintos tipos reais):

float tanf(float x);
double tan(double x);
long double tanl(long double x);

tanh

Devolve a tanxente hiperbólica. Haberá un erro se o argumento non está entre -1 e 1, e podería habelo en caso de que sexa igual a -1 ou a 1. Estes son os prototipos desta función (para os distintos tipos reais):

float tanhf(float x);
double tanh(double x); 
long double tanhl(long double x);

tgamma

Función gamma. Estes son os prototipos desta función (para os distintos tipos reais):

float tgammaf(float x);
double tgamma(double x);
long double tgammal(long double x);

trunc

Redondear o argumento ao valor enteiro menor que o argumento que máis preto estea del. Estes son os prototipos desta función (para os distintos tipos reais):

float truncf(float x);
double trunc(double x);
long double truncl(long double x);

Utilizar as claves desta biblioteca en Windows

Para poder utilizar as claves matemáticas da biblioteca estándar de C en sistemas Windows, é necesario situar entre as directrices para o preprocesador a seguinte liña:

#define _USE_MATH_DEFINES

Precedendo á inclusión do ficheiro de cabeceira math.h:

#include <math.h>

C
← Volver a locale.h	math.h	Seguir con setjmp.h →