C/math.h: Diferenzas entre revisións
Contido eliminado Contido engadido
Gardo e sigo traballando (este ficheiro de cabeceira resulta un verdadeiro coñazo). |
Bueno, xa falta menos. |
||
Liña 78:
===<code>ceil</code>===
Redondeo cara arriba, calcular o menor enteiro maior que o parámetro. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float ceilf(float x);
double ceil(double x);
long double ceill(long double x);
</source>
===<code>copysign</code>===
Liña 100 ⟶ 105:
===<code>erf</code>===
Función de erro. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float erff(float x);
double erf(double x);
long double erfl(long double x);
</source>
===<code>erfc</code>===
Función de erro complementaria. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float erfcf(float x);
double erfc(double x);
long double erfcl(long double x);
</source>
===<code>exp</code>===
Liña 130 ⟶ 145:
===<code>fabs</code>===
Valor absoluto (dun número real). Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float fabsf(float x);
double fabs(double x);
long double fabsl(long double x);
</source>
===<code>fdim</code>===
Liña 136 ⟶ 156:
===<code>floor</code>===
Redondeo cara abaixo, calcular o maior enteiro menor que o parámetro. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float floorf(float x);
double floor(double x);
long double floorl(long double x);
</source>
===<code>fma</code>===
Liña 148 ⟶ 173:
===<code>fmod</code>===
Resto (dunha división de números reais). Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float fmodf(float x, float y);
double fmod(double x, double y);
long double fmodl(long double x, long double y);
</source>
===<code>frexp</code>===
Liña 185 ⟶ 215:
===<code>lgamma</code>===
Logaritmo natural do valor absoluto da función gamma. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float lgammaf(float x);
double lgamma(double x);
long double lgammal(long double x);
</source>
===<code>llint</code>===
Redondear a un enteiro co método actual. Devolve o valor co tipo <source lang=c enclose=none>long long int</source>. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
long long int llrintf(float x);
long long int llrint(double x);
long long int llrintl(long double x);
</source>
===<code>llround</code>===
Redondear a un enteiro. Devolve o valor co tipo <source lang=c enclose=none>long long int</source>. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
long long int llroundf(float x);
long long int llround(double x);
long long int llroundl(long double x);
</source>
===<code>log</code>===
Liña 234 ⟶ 279:
===<code>lrint</code>===
Redondear a un enteiro co método actual. Devolve o valor co tipo <source lang=c enclose=none>long int</source>. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
long int lrintf(float x);
long int lrint(double x);
long int lrintl(long double x);
</source>
===<code>lround</code>===
Redondear a un enteiro. Devolve o valor co tipo <source lang=c enclose=none>long int</source>. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
long int lroundf(float x);
long int lround(double x);
long int lroundl(long double x);
</source>
===<code>modf</code>===
Liña 251 ⟶ 306:
===<code>nearbyint</code>===
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):
<source lang=c>
float nearbyintf(float x);
double nearbyint(double x);
long double nearbyintl(long double x);
</source>
===<code>nextafter</code>===
Liña 270 ⟶ 330:
===<code>remainder</code>===
<source lang=c enclose=none>remainder(x, y)</source> calcula o resto da división entre ambos parámetros. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float remainderf(float x, float y);
double remainder(double x, double y);
long double remainderl(long double x, long double y);
</source>
===<code>remquo</code>===
<source lang=c enclose=none>remquo(x, y, p)</source> actúa igual que [[#remainder|<source lang=c enclose=none>remainder(x, y)</source>]], salvo porque ademais almacena o cociente onde apunta o punteiro como <source lang=c enclose=none>int</source>. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
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);
</source>
===<code>rint</code>===
Redondear a un enteiro utilizando o modo de redondeo actual
<source lang=c>
float rintf(float x);
double rint(double x);
long double rintl(long double x);
</source>
===<code>round</code>===
Redondear a un enteiro, redondeando os casos intermedios en dirección oposta ao cero.
<source lang=c>
float roundf(float x);
double round(double x);
long double roundl(long double x);
</source>
===<code>scalbln</code>===
Liña 338 ⟶ 418:
===<code>tgamma</code>===
Función gamma. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float tgammaf(float x);
double tgamma(double x);
long double tgammal(long double x);
</source>
===<code>trunc</code>===
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):
<source lang=c>
float truncf(float x);
double trunc(double x);
long double truncl(long double x);
</source>
==Utilizar as claves desta biblioteca en Windows==
| |||