Revisión como estaba o 10 de agosto de 2010 ás 08:22 editar Gallaecio (conversa \| contribucións) 4.675 edicións Vou gardando. Completar isto é un coñazo, así que vou botar unha soneca a ver se esperto con máis ganas. ← Edición máis vella		Revisión como estaba o 10 de agosto de 2010 ás 15:15 editar desfacer Gallaecio (conversa \| contribucións) 4.675 edicións Gardo e sigo traballando (este ficheiro de cabeceira resulta un verdadeiro coñazo). Edición máis nova →
Liña 70: ===<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): ~~Raíz cúbica.~~ <source lang=c> float cbrtf(float x); double cbrt(double x); long double cbrtl(long double x); </source> ===<code>ceil</code>=== Liña 154 ⟶ 159: ===<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> float hypotf(float x, float y); double hypot(double x, double y); long double hypotl(long double x, long double y); </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>]]. ~~O expoñente dun valor de tipo <source lang=c enclose=none>float</source>, convertido en <source lang=c enclose=none>int</source>.~~ Estes son os prototipos desta función (para os distintos tipos reais): <source lang=c> int ilogbf(float x); int ilogb(double x); int double ilogbl(long double x); </source> ===<code>ldexp</code>=== Liña 177 ⟶ 194: ===<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): ~~Logaritmo natural.~~ <source lang=c> float logf(float x); double log(double x); long double logl(long double x); </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): ~~Logaritmo en base 10.~~ <source lang=c> float log10f(float x); double log10(double x); long double log10l(long double x); </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> float log1pf(float x); double log1p(double x); long double log1pl(long double x); </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): ~~Logaritmo en base 2.~~ <source lang=c> float log2f(float x); double log2(double x); long double log2l(long double x); </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): ~~Extrae o expoñente dun número real.~~ <source lang=c> float logbf(float x); double logb(double x); long double logbl(long double x); </source> ===<code>lrint</code>=== Liña 198 ⟶ 240: ===<code>modf</code>=== <source lang=c enclose=none>modf(x, p)</source> ~~devolve~~divide ao ~~parte~~valor de <code>x</code> nas súas partes fraccionaria dee 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> float modff(float value, float iptr); double modf(double value, double iptr); long double modfl(long double value, long double *iptr); </source> ===<code>nan</code>=== Liña 213 ⟶ 260: ===<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. Estes son os prototipos desta función (para os distintos tipos reais): <source lang=c> float powf(float x, float y); double pow(double x, double y); long double powl(long double x, long double y); </source> ===<code>remainder</code>=== Liña 228 ⟶ 282: ===<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> float scalblnf(float x, long int ex); double scalbln(double x, long int ex); long double scalblnl(long double x, long int ex); </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> float scalbnf(float x, int ex); double scalbn(double x, int ex); long double scalbnl(long double x, int ex); </source> ===<code>sin</code>=== Liña 250 ⟶ 314: ===<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): ~~Raíz cadrada.~~ <source lang=c> float sqrtf(float x); double sqrt(double x); long double sqrtl(long double x); </source> ===<code>tan</code>===

C/math.h: Diferenzas entre revisións