math – Mathematical functions¶ (Español)

Number-theoretic and representation functions¶

math.ceil(x)¶

devuelve el techo de x, el entero más pequeño mayor o igual que x.Si x no es un flotador, delega en x.__ceil__(), que debería devolver un valorIntegral.

math.comb(n, k)¶

devuelve el número de formas de elegir k elementos de n elementos sin repeticióny sin orden.,

devuelve n! / (k! * (n - k)!) cuando k <= n y evaluatesto cero cuando k > n.

También llamado coeficiente binomial porque es equivalente al coeficiente de k-ésimo término en la expansión polinómica de la expresión (1 + x) ** n.

Plantea TypeError si cualquiera de los argumentos no son enteros.Eleva ValueError si cualquiera de los argumentos es negativo.

math.copysign(x, y)¶math.fabs(x)¶

Return the absolute value of x.

math.factorial(x)¶

Return x factorial as an integer. Raises ValueError if x is not integral oris negative.

math.floor(x)¶math.fmod(x, y)¶

Volver fmod(x, y), tal como se define por la plataforma C de la biblioteca. Tenga en cuenta que la expresión Python x % y puede no devolver el mismo resultado. La intención de la Cstandard es que el fmod(x, y) ser exactamente (matemáticamente; a infiniteprecision) igual a x - n*y para algún entero n tal que el resultado tiene el mismo signo que x y magnitud menor que abs(y)., Python x % y devuelve un resultado con el signo de y en su lugar, y puede no ser exactamente computable para argumentos float. Por ejemplo, fmod(-1e-100, 1e100) es -1e-100, pero el resultado de Python -1e-100 % 1e100 es 1e100-1e-100, que no berepresented exactamente como un flotador, y se redondea a la sorprendente 1e100. Por esta razón, la función fmod() se prefiere generalmente cuando se trabaja con floats, mientras que el x % y de Python se prefiere cuando se trabaja con enteros.,

math.frexp(x)¶math.fsum(iterable)¶

Volver precisa de punto flotante suma de los valores en la iterable. Evita la pérdida de precisión rastreando múltiples sumas parciales intermedias:

>>> sum()0.9999999999999999>>> fsum()1.0

la precisión del algoritmo depende de las garantías aritméticas IEEE-754 y del caso típico donde el modo de redondeo es medio par., En algunas construcciones no-Windowsbuilds, la biblioteca de C subyacente utiliza la adición de precisión extendida y ocasionalmente puede doblar una suma intermedia causando que esté desactivada en su último bit significativo.

para una discusión más detallada y dos enfoques alternativos, vea los COOKBOOKRECIPES de ASPN para una suma precisa de punto flotante.

math.gcd(*enteros)¶

devuelve el máximo común divisor de los argumentos enteros.Si alguno de los argumentos es distinto de cero, entonces el valor devuelto es el entero largestpositive que es un divisor de todos los argumentos., Si todos los argumentos son cero, entonces el valor devuelto es 0. gcd()sin argumentos 0.

math.isclose(a, b, *, rel_tol=1E-09, abs_tol=0.0)¶

Return True si los valores a y b están cerca entre sí yFalse de lo contrario.,

si dos valores se consideran cercanos o no se determina de acuerdo con las tolerancias absolutas y relativas dadas.

rel_tol es la tolerancia relativa-es la diferencia máxima permitida entre a y b, en relación con el valor absoluto más grande de A O b.por ejemplo, para establecer una tolerancia de 5%, pase rel_tol=0.05. La tolerancia defaulttolerance es 1e-09, lo que asegura que los dos valores son el mismo dentro de aproximadamente 9 dígitos decimales. rel_tol debe ser mayor que cero.

abs_tol es la tolerancia absoluta mínima-útil para comparaciones nearzero., abs_tol debe ser al menos cero.

Si no se producen errores, el resultado será:abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

los valores especiales de IEEE 754 de NaN, inf, y -inf se aplicarán de acuerdo con las reglas de IEEE. Específicamente, NaNno se considera cercano a ningún otro valor, incluido NaN. infy -inf solo se consideran cerca de sí mismos.

math.isfinite(x)¶

Return True if x is neither an infinity nor a NaN, andFalse otherwise. (Note that 0.0 is considered finite.)

math.isinf(x)¶

Return True if x is a positive or negative infinity, andFalse otherwise.,

math.isnan(x)¶

Volver True si x es un NaN (no un número), y False en caso contrario.

math.isqrt(n)¶

devuelve la raíz cuadrada entera del entero no negativo n. Este es el piso de la raíz cuadrada exacta de n, o equivalentemente la mayor integera tal que a2 ≤ n.

para algunas aplicaciones, puede ser más conveniente tener la menor integera tal que n ≤ A2, o en otras palabras el techo de la raíz cuadrada exacta de N., Para n positivo, esto se puede calcular usandoa = 1 + isqrt(n - 1).

math.lcm(*enteros)¶

Volver el mínimo común múltiplo de los argumentos enteros.Si todos los argumentos son distintos de cero, entonces el valor devuelto es el entero positivo más pequeño que es un múltiplo de todos los argumentos. Si alguno de los argumentos es cero, entonces el valor devuelto es 0. lcm()sin argumentos 1.

math.ldexp(x, i)¶

Volver x * (2**i). Esto es esencialmente el inverso de la funciónfrexp().

math.modf(x)¶

devuelve las partes fraccionarias y enteras de x. ambos resultados llevan el signo de x y son flotadores.

Volver el próximo valor de punto flotante después de x hacia y.

Si x es igual a y, de retorno y.

Ejemplos:

Véase también math.ulp().

math.perm(n, k=None)¶

devuelve el número de formas de elegir k elementos de n artículos sin repetición y con orden.

devuelve n! / (n - k)! cuando k <= n y evaluatesto cero cuando k > n.

si k no está especificado o no es ninguno, entonces k por defecto es nand la función devuelve n!.

Plantea TypeError si cualquiera de los argumentos no son enteros.Eleva ValueError si cualquiera de los argumentos es negativo.,

math.prod(iterable, *, start=1)¶

Calcular el producto de todos los elementos en la entrada iterable.El valor de inicio predeterminado para el producto es 1.

Cuando el iterable está vacío, devuelve el valor de inicio. Esta función está pensada específicamente para su uso con valores numéricos y puede rechazar tipos no numéricos.

math.remainder(x, y)¶

devuelve el resto de x al estilo IEEE 754 con respecto a y., Forfinite x y finito distinto de cero y, esta es la diferencia x - n*y,donde n es el entero más cercano el valor exacto del cociente x /y. Si x / yestá exactamente a medio camino entre dos enteros consecutivos, el entero par más cercano se usa para n. El resto r = remainder(x,y) siempre satisface abs(r) <= 0.5 * abs(y).,

los casos especiales siguen a IEEE 754: en particular, remainder(x, math.inf) isx para cualquier x finita, y remainder(x, 0) yremainder(math.inf, x) raise ValueError para cualquier x.si el resultado de la operación restante es cero, ese cero tendrá el mismo signo que x.

en plataformas que usan coma flotante binario IEEE 754, el resultado de esta operación siempre es exactamente representable: no se introduce ningún error de redondeo.

math.trunc(x)¶

Volver Real valor de x trunca a unIntegral (generalmente un número entero). Delega enx.__trunc__().

math.ulp(x)¶

devuelve el valor del bit menos significativo del float x:

• Si x es un NaN (no un número), el rendimiento de x.

• Si x es negativo, volver ulp(-x).

• Si x es un infinito positivo, retorno de x.,

• Si x es igual a cero, devuelve el flotador representable positivedenormalized más pequeño (más pequeño que el flotador positivenormalized mínimo, sys.float_info.min).

• Si x es igual al flotador representable positivo más grande, devuelve el valor del bit menos significativo de x, de modo que el primer flotador más pequeño que x es x - ulp(x).

• de lo contrario (x es un número finito positivo), devuelve el valor del bit menos significativo de x, de modo que el primer flotador mayor que xis x + ulp(x).,

ULP significa «Unidad en el Último Lugar».

Véase también math.nextafter() y sys.float_info.epsilon.

tenga en cuenta que frexp()y modf() tienen un patrón de llamada/retorno diferente al de sus equivalentes C: toman un solo argumento y devuelven un par de valores, en lugar de devolver su segundo valor de retorno a través de un ‘outputparameter’ (no hay tal cosa en Python).,

para las funciones ceil(), floor(), y modf(), tenga en cuenta que todos los números de punto flotante de magnitud suficientemente grande son enteros exactos.Los flotadores de Python normalmente no llevan más de 53 bits de precisión (lo mismo que el tipo doble de plataforma C), En cuyo caso cualquier flotador x con abs(x) >= 2**52necesariamente no tiene bits fraccionarios.