C/math.h: Diferenzas entre revisións

Contido eliminado Contido engadido
Gallaecio (conversa | contribucións)
Bueno, xa falta menos.
m Bot: Cambios estética
 
Liña 10:
</source>
 
== Funcións ==
Os ángulos exprésanse en {{W|Radián|radiáns}}. Todas as funcións traballan con tipos <source lang=c enclose=none>double</source>, salvo que se indique o contrario. Para traballar con tipos <source lang=c enclose=none>float</source> sufíxase o identificador da función cun «<code>f</code>», e para traballar con tipos <source lang=c enclose=none>long double</source> sufízase cun «<code>l</code>».
 
=== <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):
<source lang=c>
Liña 21:
</source>
 
=== <code>acosh</code> ===
Coseno inverso hiperbólico. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 29:
</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):
<source lang=c>
Liña 37:
</source>
 
=== <code>asinh</code> ===
Seno inverso hiperbólico. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 45:
</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):
<source lang=c>
Liña 53:
</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):
<source lang=c>
Liña 61:
</source>
 
=== <code>atanh</code> ===
Tanxente inversa hiperbólica. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 69:
</source>
 
=== <code>cbrt</code> ===
<source lang=c enclose=none>cbrt(x)</source> devolve a raíz cúbica de <code>x</code>. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 77:
</source>
 
=== <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>
Liña 85:
</source>
 
=== <code>copysign</code> ===
<source lang=c enclose=none>copysign(x, y)</source> devolve o valor de <code>x</code> co signo de <code>y</code>.
 
=== <code>cos</code> ===
Devolve o coseno en radiáns. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 96:
</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):
<source lang=c>
Liña 104:
</source>
 
=== <code>erf</code> ===
Función de erro. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 112:
</source>
 
=== <code>erfc</code> ===
Función de erro complementaria. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 120:
</source>
 
=== <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):
<source lang=c>
Liña 128:
</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>
Liña 136:
</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>
Liña 144:
</source>
 
=== <code>fabs</code> ===
Valor absoluto (dun número real). Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 152:
</source>
 
=== <code>fdim</code> ===
<source lang=c enclose=none>fdim(x, y)</source> devolve a diferencia positiva entre <code>x</code> e <code>y</code>. É equivalente a «<source lang=c enclose=none>fmax(x-y, 0)</source>».
 
=== <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>
Liña 163:
</source>
 
=== <code>fma</code> ===
<source lang=c enclose=none>fma(x, y, z)</source> devolve o valor de «<source lang=c enclose=none>(x * y) + z</source>». É o que se coñece coma “multiplicar e engadir”.
 
=== <code>fmax</code> ===
<source lang=c enclose=none>fmax(x, y)</source> devolve o valor máximo, <code>x</code> ou <code>y</code>.
 
=== <code>fmin</code> ===
<source lang=c enclose=none>fmin(x, y)</source> devolve o valor mínimo, <code>x</code> ou <code>y</code>.
 
=== <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>
Liña 180:
</source>
 
=== <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):
<source lang=c>
Liña 188:
</source>
 
=== <code>hypot</code> ===
<source lang=c enclose=none>hypot(x, y)</source> devolve a hipotenusa de <code>x</code> e <code>y</code>. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 196:
</source>
 
=== <code>ilogb</code> ===
<source lang=c enclose=none>ilogb(x)</source> extrae o expoñente de <code>x</code> e o devolve como <source lang=c enclose=none>signed int</source>. Se <code>x</code> vale cero, a función devolve a clave <code>FP_ILOGB0</code>. Se <code>x</code> vale infinito, a función devolve a clave <code>INT_MAX</code>. Se <code>x</code> é “NaN” (''Not A Number'', «non é un número»), a función devolve a clave <code>FP_ILOGBNAN</code>. En calquera outro caso, a función equivale a chamar á función [[#logb|<source lang=c enclose=none>logb</source>]] correspondente e devolver o valor como <source lang=c enclose=none>int</source>. Podería haber un erro de superación dos límites se <code>x</code> vale cero. As claves <code>FP_ILOGB0</code> e <code>FP_ILOGBNAN</code> están definidas en [[{{BASEPAGENAME}}/math.h|<code>math.h</code>]], e <code>INT_MAX</code> en [[{{BASEPAGENAME}}/limits.h|<code>limits.h</code>]].
 
Liña 206:
</source>
 
=== <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):
<source lang=c>
Liña 214:
</source>
 
=== <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>
Liña 222:
</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>
Liña 230:
</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>
Liña 238:
</source>
 
=== <code>log</code> ===
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):
<source lang=c>
Liña 246:
</source>
 
=== <code>log10</code> ===
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):
<source lang=c>
Liña 254:
</source>
 
=== <code>log1p</code> ===
<source lang=c enclose=none>log1p(x)</source> devolve o logaritmo natural de «<code>x</code> + 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):
<source lang=c>
Liña 262:
</source>
 
=== <code>log2</code> ===
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):
<source lang=c>
Liña 270:
</source>
 
=== <code>logb</code> ===
<source lang=c enclose=none>logb(x)</source> extrae o expoñente de <code>x</code> e o devolve coma <source lang=c enclose=none>int</source> en coma flotante. Se <code>x</code> é “subnormal”, trátase coma se estivese normalizado. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 278:
</source>
 
=== <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>
Liña 286:
</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>
Liña 294:
</source>
 
=== <code>modf</code> ===
<source lang=c enclose=none>modf(x, p)</source> divide o valor de <code>x</code> nas súas partes fraccionaria e enteira, cada unha delas co mesmo signo que <code>x</code>. Devolve a parte fraccionaria e almacena a parte enteira no apuntado polo [[{{BASEPAGENAME}}/Punteiros|punteiro]] <code>p</code>. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 302:
</source>
 
=== <code>nan</code> ===
<source lang=c enclose=none>nan(s)</source> devolve un “NaN” (''Not A Number'', «non é un número»), coa posibilidade de que o argumento sexa unha cadea de caracteres.
 
=== <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>
Liña 313:
</source>
 
=== <code>nextafter</code> ===
<source lang=c enclose=none>nextafter(x, y)</source> devolve o seguinte valor representable despois de <code>x</code> (cara <code>y</code>)
 
=== <code>nexttoward</code> ===
Idéntico a [[#nextafter|<source lang=c enclose=none>pow(x, y)</source>]], coa diferencia de que <code>y</code> é sempre de tipo <source lang=c enclose=none>long double</source>.
 
=== <code>pow</code> ===
<source lang=c enclose=none>pow(x, y)</source> eleva <code>x</code> a <code>y</code>, «<code>x</code><sup><code>y</code></sup>». Pode ocorrer un erro se <code>x</code> é negativo e <code>y</code> non é un valor integral, ou se o resultado non pode representarse cando <code>x</code> vale cero e <code>y</code> é cero ou menor. Asemade, podería ocorrer algún erro relativo á superación de límites.
 
Liña 329:
</source>
 
=== <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>
Liña 337:
</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>
Liña 345:
</source>
 
=== <code>rint</code> ===
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):
<source lang=c>
Liña 353:
</source>
 
=== <code>round</code> ===
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):
<source lang=c>
Liña 361:
</source>
 
=== <code>scalbln</code> ===
<source lang=c enclose=none>scalbln(x, n)</source> equivale a «<code>x</code> × <code>FLT_RADIX</code> <sup><code>n</code></sup>>», onde <code>n</code> é de tipo <source lang=c enclose=none>long int</source>. <code>FLT_RADIX</code> é 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|<code>ldexp</code>]]. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 369:
</source>
 
=== <code>scalbn</code> ===
<source lang=c enclose=none>scalbln(x, n)</source> equivale a «<code>x</code> × <code>FLT_RADIX</code> <sup><code>n</code></sup>>», onde <code>n</code> é de tipo <source lang=c enclose=none>int</source>. <code>FLT_RADIX</code> é 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|<code>ldexp</code>]]. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 377:
</source>
 
=== <code>sin</code> ===
Devolve o seno en radiáns. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 385:
</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):
<source lang=c>
Liña 393:
</source>
 
=== <code>sqrt</code> ===
<source lang=c enclose=none>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>
Liña 401:
</source>
 
=== <code>tan</code> ===
Devolve a tanxente en radiáns. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 409:
</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):
<source lang=c>
Liña 417:
</source>
 
=== <code>tgamma</code> ===
Función gamma. Estes son os prototipos desta función (para os distintos tipos reais):
<source lang=c>
Liña 425:
</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>
Liña 433:
</source>
 
== Utilizar as claves desta biblioteca en Windows ==
Para poder utilizar as claves matemáticas da biblioteca estándar de C en sistemas {{W|Windows}}, é necesario situar entre as [[{{BASEPAGENAME}}/Directrices para o preprocesador|directrices para o ''preprocesador'']] a seguinte liña:
<source lang=c>
Liña 448:
 
<!-- Categorías: -->
 
[[Categoría:C ─ Biblioteca estándar|math]]