Matemáticas#
Introducción#
El módulo de matemáticas incluye tanto funciones integradas de Python como el módulo completo math , disponible automáticamente en VEXcode AIR. Estas herramientas permiten realizar desde operaciones aritméticas básicas hasta trigonometría avanzada, redondeo y operaciones logarítmicas.
Utilice estas funciones y constantes para calcular posiciones, ángulos, distancias y otros valores numéricos para el controlador de drones VEX AIR. También puedes convertir entre grados y radianes, evaluar expresiones y trabajar con valores especiales como infinito y NaN.
Nota: Excepto cuando se indique explícitamente lo contrario, todos los valores de retorno tienen formato flotante con exactamente cinco decimales. Los valores con más de cinco decimales se redondean y los valores con menos de cinco decimales se extienden con ceros para que siempre se muestren exactamente cinco decimales.
A continuación se muestra una lista de funciones, constantes y utilidades matemáticas disponibles:
Funciones integradas: herramientas matemáticas comunes incluidas con Python.
abs– Devuelve el valor absoluto de un número.round– Redondea un número a un número específico de decimales.min– Devuelve el menor de los valores de entrada.max– Devuelve el mayor de los valores de entrada.sum– Suma todos los valores en un iterable.divmod– Devuelve el cociente y el resto como una tupla.pow– Eleva un número a una potencia, opcionalmente con un módulo.int– Convierte un valor en un número entero.float– Convierte un valor en un número de punto flotante.
Constantes: Valores predefinidos del módulo math.
math.pi– La constante π (pi).math.tau– La constante tau (2π).math.e– Número de Euler, base del registro natural.math.inf– Infinito positivo.math.nan– No es un número (NaN).
Trigonometría: calcula los ángulos y las relaciones entre los lados.
math.sin– Seno de un ángulo en radianes.math.cos– Coseno de un ángulo en radianes.math.tan– Tangente de un ángulo en radianes.math.asin– Arcseno de un valor en radianes.math.acos– Arccoseno de un valor en radianes.math.atan– Arcotangente de un valor en radianes.math.atan2– Arcotangente de y/x en radianes, considerando el cuadrante.math.degrees– Convierte radianes en grados.math.radians– Convierte grados a radianes.
Hiperbólica: funciones avanzadas relacionadas con trigonomas.
math.sinh– Seno hiperbólico de un valor.math.cosh– Coseno hiperbólico de un valor.math.tanh– Tangente hiperbólica de un valor.math.asinh– Seno hiperbólico inverso.math.acosh– Coseno hiperbólico inverso.math.atanh– Tangente hiperbólica inversa.
Redondeo y valor absoluto: ajuste la precisión o la dirección.
math.ceil– Redondea al número entero más cercano.math.floor– Redondea al entero más cercano.math.trunc– Elimina la parte decimal.math.fabs– Devuelve el valor absoluto como un valor flotante.
Exponentes y logaritmos: cálculos de potencia, raíz y registro.
math.pow– Eleva un número a una potencia.math.sqrt– Devuelve la raíz cuadrada.math.exp– Calcula e a la potencia de x.math.log– Logaritmo natural (base e).math.log10– Logaritmo de base 10.math.log2– Logaritmo de base 2.math.factorial– Factorial de un entero.math.expm1– Resultado más preciso parae^x - 1.
Operaciones en coma flotante: inspeccione o descomponga los valores flotantes.
math.modf– Devuelve las partes fraccionarias y enteras de un flotador.math.frexp– Descompone un número en mantisa y exponente.math.fmod– Resto con signo del dividendo.math.copysign– Devuelve un valor con el signo de otro.math.ldexp– Calculax * (2 ** exp).
Comparación y aproximación: compruebe los valores con tolerancias o categorías.
math.isfinite– Comprueba si un número es finito.math.isinf– Comprueba si un número es infinito.math.isnan– Comprueba si un valor es NaN.
Error y Gamma – Funciones matemáticas especiales.
math.gamma– Función gamma (factorial generalizado).math.lgamma– Gamma logarítmica.math.erf– Función de error.math.erfc– Función de error complementaria.
Funciones integradas#
Python proporciona varias funciones integradas que le permiten realizar operaciones matemáticas dentro de su proyecto.
abs#
abs devuelve el valor absoluto de un número, eliminando cualquier signo negativo.
Usage:
abs(x)
Parámetro |
Descripción |
|---|---|
|
Un número entero o flotante. |
# Get the absolute value of -10
abs_result = abs(-10)
controller.screen.print(abs_result)
# abs_result = 10
round#
round devuelve un número redondeado a un número especificado de decimales como un entero.
Usage:
round(x, ndigits)
Parámetro |
Descripción |
|---|---|
|
Un número entero o flotante. |
|
Opcional. Controla cuántos decimales redondear (entre 0 y 5). El valor predeterminado es 0. Cuando se utiliza este parámetro, |
# Round 5.7 to the nearest integer
round_int_result = round(5.7)
controller.screen.print(round_int_result)
# round_int_result = 6
# Round 3.14159 to 2 decimal places
round_result = round(3.14159, 2)
controller.screen.print(round_result)
# round_result = 3.14000
min#
min devuelve el valor más pequeño de varios argumentos o un iterable.
Usage:
min(arg1, arg2, …) or min(sequence)
Parámetro |
Descripción |
|---|---|
|
Los números a comparar. |
|
Una lista, tupla u otra secuencia que contenga números. |
# Get the smallest number from 3, 7, and 1
min_result = min(3, 7, 1)
controller.screen.print(min_result)
# min_result = 1
# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
controller.screen.print(min_list_result)
# min_list_result = 1
max#
max devuelve el valor más grande de múltiples argumentos o un iterable.
Usage:
max(arg1, arg2, …) or max(sequence)
Parámetro |
Descripción |
|---|---|
|
Los números a comparar. |
|
Una lista, tupla u otra secuencia que contenga números. |
# Get the largest number from 3, 7, and 1
max_result = max(3, 7, 1)
controller.screen.print(max_result)
# max_result = 7
# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
controller.screen.print(max_list_result)
# max_list_result = 25
sum#
sum suma todos los valores en un iterable, con un valor inicial opcional.
Usage:
sum(sequence, start)
Parámetro |
Descripción |
|---|---|
|
Una lista, tupla u otra secuencia que contenga números. |
|
Opcional. Un valor para agregar a la suma. El valor predeterminado es 0. |
# Calculate the sum of a list of numbers
sum_result = sum([1, 2, 3, 4, 5])
controller.screen.print(sum_result)
# sum_result = 15
# Calculate the sum of a list with a starting value of 10
sum_with_start = sum([1, 2, 3], 10)
controller.screen.print(sum_with_start)
# sum_with_start = 16
divmod#
divmod devuelve una tupla que contiene el cociente y el resto de una operación de división.
Usage:
divmod(a, b)
Parámetro |
Descripción |
|---|---|
|
El dividendo. |
|
El divisor. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
controller.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow devuelve un número elevado a una potencia y, opcionalmente, realiza una operación de módulo como un número entero.
Usage:
pow(x, y, mod)
Parámetro |
Descripción |
|---|---|
|
El número base. |
|
El exponente. |
|
Opcional. Un valor de módulo. Si se proporciona, devuelve |
# Calculate 2 raised to the power of 3
pow_result = pow(2, 3)
controller.screen.print(pow_result)
# pow_result = 8
# Calculate (5 ** 3) % 7
pow_mod_result = pow(5, 3, 7)
controller.screen.print(pow_mod_result)
# pow_mod_result = 6
int#
>int convierte un número o cadena en un entero. También admite la conversión base al convertir desde una cadena.
Usage:
int(x, base)
Parámetro |
Descripción |
|---|---|
|
Un número, cadena u otro objeto para convertir. |
|
Opcional. La base numérica a utilizar para la conversión. El valor predeterminado es 10. |
# Convert a float to an integer to get rid of decimals
price = 19.99
price_int = int(price)
controller.screen.print(f"{price_int} coins")
# Output: 19 coins
# Convert a string into an integer to use in calculations
user_input = "55"
user_number = int(user_input)
controller.screen.print(user_number * 2)
# Output: 110
float#
float convierte un número o cadena en un número de punto flotante.
Usage:
float(x)
Parámetro |
Descripción |
|---|---|
|
Un número, cadena u otro objeto para convertir. |
# Convert division result to a float
num_apples = 6
num_people = 2
apples_per_person = float(num_apples) / num_people
controller.screen.print(apples_per_person)
# Output: 3.00000
# Convert a string into a float to use in calculations
user_input = "23.4"
user_number = float(user_input)
controller.screen.print(user_number * 3)
# Output: 70.20000
Módulo de Matemáticas#
El módulo math de MicroPython proporciona métodos adicionales para realizar cálculos matemáticos comunes. Estos métodos incluyen operaciones trigonométricas, logarítmicas y otras operaciones numéricas.
El módulo math se importa por defecto en VEXcode.
Constants#
Las constantes son valores predefinidos que permanecen fijos durante un proyecto. Se pueden utilizar en cálculos sin necesidad de ninguna definición o asignación.
pi#
pi da la constante matemática π, la relación entre la circunferencia de un círculo y su diámetro.
Usage:
math.pi
# Calculate the area of a circle with radius 5 using pi
circle_area = math.pi * 5 * 5
controller.screen.print(circle_area)
# circle_area = 78.53982
tau#
tau da el valor de 2π.
Usage:
math.tau
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
controller.screen.print(circumference)
# circumference = 31.41593
e#
e da la base del logaritmo natural.
Usage:
math.e
# Calculate e raised to the power of 2
e_power = math.pow(math.e, 2)
controller.screen.print(e_power)
# e_power = 7.38906
inf#
inf da un infinito positivo como un flotador.
Usage:
math.inf
# Check if infinity is infinite
inf_value = math.inf
if math.isinf(inf_value):
controller.screen.print("Infinity")
# Prints "Infinity"
nan#
nan representa un flotador especial para “Not a Number” (NaN).
Usage:
math.nan
# Check if nan is Not a Number
nan_value = math.nan
if math.isnan(nan_value):
controller.screen.print("Not a Number")
# Prints "Not a Number"
Trigonometry#
sin#
sin calcula el seno de un ángulo en radianes y devuelve un flotador.
Usage:
math.sin(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa un ángulo en radianes. |
# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
controller.screen.print(sine_result)
# sine_result = 0.50000
cos#
cos calcula el coseno de un ángulo en radianes y devuelve un flotador.
Usage:
math.cos(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa un ángulo en radianes. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
controller.screen.print(cosine_result)
# cosine_result = 0.50000
tan#
tan calcula la tangente de un ángulo en radianes y devuelve un flotador.
Usage:
math.tan(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa un ángulo en radianes. |
# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
controller.screen.print(tangent_result)
# tangent_result = 1.00000
asin#
asin calcula el seno inverso (arco seno) de un número y devuelve un flotador que representa el ángulo en radianes.
Usage:
math.asin(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero entre -1 y 1. |
# Calculate the arc sine of 0.5 in radians
arc_sine_result = math.asin(0.5)
controller.screen.print(arc_sine_result)
# arc_sine_result = 0.52360
acos#
acos calcula el coseno inverso (arco coseno) de un número y devuelve un flotador que representa el ángulo en radianes.
Usage:
>math.acos(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero entre -1 y 1. |
# Calculate the arc cosine of 0.5 in radians
arc_cosine_result = math.acos(0.5)
controller.screen.print(arc_cosine_result)
# arc_cosine_result = 1.04720
atan#
atan calcula la tangente inversa (arco tangente) de un número y devuelve un flotador que representa el ángulo en radianes.
Usage:
math.atan(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero. |
# Calculate the arc tangent of 1 in radians
arc_tangent_result = math.atan(1)
controller.screen.print(arc_tangent_result)
# arc_tangent_result = 0.78540
atan2#
atan2 calcula el valor principal de la tangente inversa de y/x y devuelve un flotador que representa el ángulo en radianes.
Usage:
math.atan2(y, x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa la coordenada y. |
|
Un flotador o número entero que representa la coordenada x. |
# Calculate the inverse tangent of (4, 3) in radians
atan2_result = math.atan2(3, 4)
controller.screen.print(atan2_result)
# atan2_result = 0.64350
grados#
degrees convierte un ángulo de radianes a grados.
Usage:
math.degrees(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa un ángulo en radianes. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
controller.screen.print(degrees_result)
# degrees_result = 180.00000
radianes#
radians convierte un ángulo de grados a radianes.
Usage:
math.radians(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa un ángulo en grados. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
controller.screen.print(radians_result)
# radians_result = 3.14159
Hyperbolics#
sinh#
sinh calcula el seno hiperbólico de x.
Usage:
math.sinh(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa el valor de entrada. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
controller.screen.print(sinh_result)
# sinh_result = 1.7520
cosh#
cosh calcula el coseno hiperbólico de x.
Usage:
math.cosh(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa el valor de entrada. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
controller.screen.print(cosh_result)
# cosh_result = 1.54308
tanh#
tanh calcula la tangente hiperbólica de x.
Usage:
math.tanh(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa el valor de entrada. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
controller.screen.print(tanh_result)
# tanh_result = 0.76159
asinh#
asinh calcula el seno hiperbólico inverso de x.
Usage:
math.asinh(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa el valor de entrada. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
controller.screen.print(asinh_result)
# asinh_result = 0.88137
acosh#
acosh calcula el coseno hiperbólico inverso de x.
Usage:
math.acosh(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero mayor o igual a 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
controller.screen.print(acosh_result)
# acosh_result = 1.31696
atanh#
atanh calcula la tangente hiperbólica inversa de x.
Usage:
math.atanh(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador entre -1 y 1 (exclusivo). |
# Calculate the inverse hyperbolic tangent of 0.5
atanh_result = math.atanh(0.5)
controller.screen.print(atanh_result)
# atanh_result = 0.54931
Rounding & Absolute Values#
techo#
ceil redondea un número hasta el entero más cercano.
Usage:
math.ceil(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero a redondear. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
controller.screen.print(ceil_result)
# ceil_result = 4
piso#
floor redondea un número hasta el entero más cercano.
Usage:
math.floor(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que se redondeará hacia abajo. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
controller.screen.print(floor_result)
# floor_result = 3
trunc#
trunc elimina la parte decimal de un número sin redondear.
Usage:
math.trunc(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador a truncar. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
controller.screen.print(trunc_result)
# trunc_result = 3
fabs#
fabs devuelve el valor absoluto de un número como un flotante.
Usage:
math.fabs(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero. |
# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
controller.screen.print(fabs_result)
# fabs_result = 3.70000
Exponents & Logarithms#
pow#
pow eleva x a la potencia de y (xy) y devuelve un float.
Usage:
math.pow(x, y)
Parámetro |
Descripción |
|---|---|
|
Una base flotante o entera. |
|
Un exponente flotante o entero. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
controller.screen.print(power_result)
# power_result = 8.00000
sqrt#
sqrt calcula la raíz cuadrada de un número y devuelve un valor flotante.
Usage:
math.sqrt(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero no negativo. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
controller.screen.print(sqrt_result)
# sqrt_result = 4.00000
exp#
exp devuelve e elevado a la potencia de x (ex) y como float.
Usage:
math.exp(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
controller.screen.print(exp_result)
# exp_result = 2.71828
registro#
log calcula el logaritmo natural de un número y devuelve un flotante.
Usage:
math.log(x)
Parámetro |
Descripción |
|---|---|
|
Un número flotante o entero positivo. |
# Calculate the natural logarithm (base e) of 7.389056
log_result = math.log(7.389056)
controller.screen.print(log_result)
# log_result = 2.00000
log10#
log10 calcula el logaritmo en base 10 de un número y devuelve un valor flotante.
Usage:
math.log10(x)
Parámetro |
Descripción |
|---|---|
|
Un número flotante o entero positivo. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
controller.screen.print(log10_result)
# log10_result = 3.00000
log2#
log2 calcula el logaritmo en base 2 de un número y devuelve un valor flotante, incluso cuando x es una potencia de 2.
Usage:
math.log2(x)
Parámetro |
Descripción |
|---|---|
|
Un número flotante o entero positivo. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
controller.screen.print(log2_result)
# log2_result = 3.00000
factorial#
factorial devuelve el factorial de un entero x, que es el producto de todos los enteros positivos hasta x.
Usage:
math.factorial(x)
Parámetro |
Descripción |
|---|---|
|
Un entero no negativo. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
controller.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 calcula ex - 1, que es más preciso para x.
Usage:
math.expm1(x)
Parámetro |
Descripción |
|---|---|
|
El valor del exponente. |
# Compute expm1(1) (e^1 - 1)
expm1_result = math.expm1(1)
controller.screen.print(expm1_result)
# expm1_result = 1.71828
Floating Point Operations#
modf#
modf descompone un número en sus partes fraccionaria y entera y devuelve una tupla (fractional part, integer part), tanto como flotantes.
Usage:
math.modf(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o entero para descomponer. |
# Decompose 3.14159 into fractional and integer parts
fractional_part, integer_part = math.modf(3.14159)
controller.screen.print(fractional_part)
controller.screen.next_row()
controller.screen.print(integer_part)
# fractional_part = 0.14159
# integer_part = 3.00000
frexp#
frexp descompone un número en su mantisa y exponente y devuelve una tupla (mantissa, exponent), donde la mantisa es un flotador y el exponente es un número entero.
Usage:
math.frexp(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o entero para descomponer. |
# Decompose 16 into its mantissa and exponent
mantissa, exponent = math.frexp(16)
controller.screen.print(mantissa)
controller.screen.next_row()
controller.screen.print(exponent)
# mantissa = 0.50000
# exponent = 5
fmod#
fmod devuelve el resto de la división manteniendo el signo del dividendo (x).
Usage:
math.fmod(x, y)
Parámetro |
Descripción |
|---|---|
|
El dividendo. |
|
El divisor. |
# Calculate remainder of 10 / 3
# that preserves the sign of 10
fmod_result = math.fmod(10, 3)
controller.screen.print(fmod_result)
# fmod_result = 1.00000
copysign#
copysign devuelve x con el signo de y.
Usage:
math.copysign(x, y)
Parámetro |
Descripción |
|---|---|
|
El valor a modificar. |
|
El valor cuyo signo se copiará. |
# Return -10 with the sign of 3 (positive)
copysign_result = math.copysign(-10, 3)
controller.screen.print(copysign_result)
# copysign_result = 10.00000
ldexp#
ldexp calcula x * (2 ** exp), que es equivalente a x * 2exp.
Usage:
math.ldexp(x, exp)
Parámetro |
Descripción |
|---|---|
|
El valor base. |
|
El exponente. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
controller.screen.print(ldexp_result)
# ldexp_result = 48.00000
Comparison & Approximation#
isfinito#
isfinite comprueba si un número es finito. Este método devuelve un valor booleano:
True: el número es finito.False: el número es infinito.
Usage:
math.isfinite(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero para verificar. |
# Check if 42 is a finite number (returns True)
is_finite_true = math.isfinite(42)
controller.screen.print(is_finite_true)
# is_finite_true = True
# Check if infinity is a finite number (returns False)
is_finite_false = math.isfinite(math.inf)
controller.screen.print(is_finite_false)
# is_finite_false = False
isinf#
isinf comprueba si un número es infinito. Este método devuelve un valor booleano:
True: el número es infinito.False: el número es finito.
Usage:
math.isinf(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero para verificar. |
# Check if infinity is an infinite number (returns True)
is_inf_true = math.isinf(math.inf)
controller.screen.print(is_inf_true)
# is_inf_true = True
# Check if 42 is an infinite number (returns False)
is_inf_false = math.isinf(42)
controller.screen.print(is_inf_false)
# is_inf_false = False
isnan#
isnan comprueba si un número es NaN (No es un número). Este método devuelve un valor booleano:
True: el número es NaN.False: el número es un número válido.
Usage:
math.isnan(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero para verificar. |
# Check if NaN (Not a Number) is NaN (returns True)
is_nan_true = math.isnan(math.nan)
controller.screen.print(is_nan_true)
# is_nan_true = True
# Check if 42 is NaN (returns False)
is_nan_false = math.isnan(42)
controller.screen.print(is_nan_false)
# is_nan_false = False
Error and Gamma Calculations#
gamma#
gamma calcula la función gamma de x, que generaliza la función factorial para números reales y complejos. Para un entero n, gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Parámetro |
Descripción |
|---|---|
|
Un número flotante o entero positivo. |
# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
controller.screen.print(gamma_result)
# gamma_result = 24.00000
lgamma#
lgamma calcula el logaritmo natural de la función gamma.
Usage:
math.lgamma(x)
Parámetro |
Descripción |
|---|---|
|
Un número flotante o entero positivo. |
# Calculate the natural logarithm of the
# gamma function of 5
lgamma_result = math.lgamma(5)
controller.screen.print(lgamma_result)
# lgamma_result = 3.17805
erf#
erf calcula la función de error de x.
Usage:
math.erf(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa el valor de entrada. |
# Calculate the error function of 1
erf_result = math.erf(1)
controller.screen.print(erf_result)
# erf_result = 0.84270
erfc#
erfc calcula la función de error complementaria de x, que se define como 1 - erf(x).
Usage:
math.erfc(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador o número entero que representa el valor de entrada. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
controller.screen.print(erfc_result)
# erfc_result = 0.15730