C/math.h: Diferenzas entre revisións

Contido eliminado Contido engadido
Gallaecio (conversa | contribucións)
Ampliación co contido dun artigo (fusionado neste).
Gallaecio (conversa | contribucións)
Vou gardando. Completar isto é un coñazo, así que vou botar unha soneca a ver se esperto con máis ganas.
Liña 14:
 
===<code>acos</code>===
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):
Coseno inverso.
<source lang=c>
float acosf(float x);
double acos(double x);
long double acosl(long double x);
</source>
 
===<code>acosh</code>===
Coseno inverso hiperbólico. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float acoshf(float x);
double acosh(double x);
long double acoshl(long double x);
</source>
 
===<code>asin</code>===
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):
Seno inverso.
<source lang=c>
float asinf(float x);
double asin(double x);
long double asinl(long double x);
</source>
 
===<code>asinh</code>===
Seno inverso hiperbólico. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float asinhf(float x);
double asinh(double x);
long double asinhl(long double x);
</source>
 
===<code>atan</code>===
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):
Tanxente inversa dun só parámetro.
<source lang=c>
float atanf(float x);
double atan(double x);
long double atanl(long double x);
</source>
 
===<code>atan2</code>===
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):
Tanxente inversa de dous parámetros.
<source lang=c>
float atan2f(float y, float x);
double atan2(double y, double x);
long double atan2l(long double y, long double x);
</source>
 
===<code>atanh</code>===
Tanxente inversa hiperbólica. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float atanhf(float x);
double atanh(double x);
long double atanhl(long double x);
</source>
 
===<code>cbrt</code>===
Liña 44 ⟶ 79:
 
===<code>cos</code>===
Devolve o coseno en radiáns. Estes son os prototipos desta función (para os distintos tipos reais):
Coseno.
<source lang=c>
float cosf(float x);
double cos(double x);
long double cosl(long double x);
</source>
 
===<code>cosh</code>===
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):
Coseno hiperbólico.
<source lang=c>
float coshf(float x);
double cosh(double x);
long double coshl(long double x);
</source>
 
===<code>erf</code>===
Liña 56 ⟶ 101:
 
===<code>exp</code>===
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):
Función exponencial.
<source lang=c>
float expf(float x);
double exp(double x);
long double expl(long double x);
</source>
 
===<code>exp2</code>===
<source lang=c enclose=none>exp2(x)</source> eleva 2 ao expoñente <code>x</code>, «2<sup><code>x</code></sup>». Pode haber un erro se a magnitude do argumento é demasiado grande. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float exp2f(float x);
double exp2(double x);
long double exp2l(long double x);
</source>
 
===<code>expm1</code>===
Un menos que o exponencial de <code>x</code>, «e<sup><code>x</code></sup>-1». Pode haber un erro se a magnitude do argumento é demasiado grande. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
float expm1f(float x);
double expm1(double x);
long double expm1l(long double x);
</source>
 
===<code>fabs</code>===
Liña 86 ⟶ 146:
 
===<code>frexp</code>===
<source lang=c enclose=none>frexp(x, p)</source> separa a mantisa e mailo expoñente de <code>x</code>, gardando o expoñente na variable de tipo <sourc lang=c enclose=none>int</source> á que apunta <code>p</code> 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):
Dividir en mantisa e expoñente.
<source lang=c>
float frexpf(float value, int *ex);
double frexp(double value, int *ex);
long double frexpl(long double value, int *ex);
</source>
 
===<code>hypot</code>===
Liña 95 ⟶ 160:
 
===<code>ldexp</code>===
<source lang=c enclose=none>ldexp(x, y)</source> multiplica o número real <code>x</code> por unha potencia <code>y</code> (de tipo <source lang=c enclose=none>int</source>) de 2 e devolve o resultado. Noutras palabras, devolve unha copia de <code>x</code> co seu expoñente aumentado en <code>y</code>. Pode haber un erro por superación dos límites do tipo. Estes son os prototipos desta función (para os distintos tipos reais):
Escalar segundo un expoñente.
<source lang=c>
float ldexpf(float x, int ex);
double ldexp(double x, int ex);
long double ldexpl(long double x, int ex);
</source>
 
===<code>lgamma</code>===
Liña 164 ⟶ 234:
 
===<code>sin</code>===
Devolve o seno en radiáns. Estes son os prototipos desta función (para os distintos tipos reais):
Seno.
<source lang=c>
float sinf(float x);
double sin(double x);
long double sinl(long double x);
</source>
 
===<code>sinh</code>===
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):
Seno hiperbólico.
<source lang=c>
float sinhf(float x);
double sinh(double x);
long double sinhl(long double x);
</source>
 
===<code>sqrt</code>===
Liña 173 ⟶ 253:
 
===<code>tan</code>===
Devolve a tanxente en radiáns. Estes son os prototipos desta función (para os distintos tipos reais):
Tanxente.
<source lang=c>
float tanf(float x);
double tan(double x);
long double tanl(long double x);
</source>
 
===<code>tanh</code>===
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):
Tanxente hiperbólica.
<source lang=c>
float tanhf(float x);
double tanh(double x);
long double tanhl(long double x);
</source>
 
===<code>tgamma</code>===