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 AIM. 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 su robot. También puedes convertir entre grados y radianes, evaluar expresiones y trabajar con valores especiales como infinito y NaN.
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.atan– Arcotangente de un valor en radianes.math.atan2– Arcotangente de y/x en radianes, considerando el cuadrante.math.asin– Arcseno de un valor en radianes.math.acos– Arccoseno de un valor en radianes.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.isclose: prueba si dos valores son aproximadamente iguales.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)
robot.screen.print(abs_result)
# abs_result = 10
round#
round redondea un número a un número específico de decimales.
Usage:
round(x, ndigits)
Parámetro |
Descripción |
|---|---|
|
Un número entero o flotante. |
|
Opcional. El número de decimales a redondear. El valor predeterminado es 0. |
# Round 5.7 to the nearest integer
round_int_result = round(5.7)
robot.screen.print(round_int_result)
# round_int_result = 6
# Round 3.14159 to 2 decimal places
round_result = round(3.14159, 2)
robot.screen.print(round_result)
# round_result = 3.14
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)
robot.screen.print(min_result)
# min_result = 1
# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
robot.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)
robot.screen.print(max_result)
# max_result = 7
# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
robot.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])
robot.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)
robot.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)
robot.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow eleva un número a una potencia y opcionalmente realiza una operación de módulo.
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)
robot.screen.print(pow_result)
# pow_result = 8
# Calculate (5 ** 3) % 7
pow_mod_result = pow(5, 3, 7)
robot.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)
robot.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)
robot.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
robot.screen.print(apples_per_person)
# Output: 3.00
# Convert a string into a float to use in calculations
user_input = "23.4"
user_number = float(user_input)
robot.screen.print(user_number * 3)
# Output: 70.20
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
robot.screen.print(circle_area)
# circle_area = 78.54
tau#
tau da el valor de 2π.
Usage:
math.tau
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
robot.screen.print(circumference)
# circumference = 31.42
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)
robot.screen.print(e_power)
# e_power = 7.39
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):
robot.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):
robot.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))
robot.screen.print(sine_result)
# sine_result = 0.50
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))
robot.screen.print(cosine_result)
# cosine_result = 0.50
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))
robot.screen.print(tangent_result)
# tangent_result = 1.00
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 degrees
arc_tangent_result = math.degrees(math.atan(1.0))
robot.screen.print(arc_tangent_result)
# arc_tangent_result = 45.00
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 1/1 in degrees
atan2_result = math.degrees(math.atan2(1.0, 1.0))
robot.screen.print(atan2_result)
# atan2_result = 45.00
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 degrees
arc_sine_result = math.degrees(math.asin(0.5))
robot.screen.print(arc_sine_result)
# arc_sine_result = 30.00
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 degrees
arc_cosine_result = math.degrees(math.acos(0.5))
robot.screen.print(arc_cosine_result)
# arc_cosine_result = 60.00
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)
robot.screen.print(degrees_result)
# degrees_result = 180.00
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)
robot.screen.print(radians_result)
# radians_result = 3.14
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)
robot.screen.print(sinh_result)
# sinh_result = 1.18
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)
robot.screen.print(cosh_result)
# cosh_result = 1.54
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)
robot.screen.print(tanh_result)
# tanh_result = 0.76
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)
robot.screen.print(asinh_result)
# asinh_result = 0.88
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)
robot.screen.print(acosh_result)
# acosh_result = 1.32
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)
robot.screen.print(atanh_result)
# atanh_result = 0.55
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)
robot.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)
robot.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)
robot.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)
robot.screen.print(fabs_result)
# fabs_result = 3.70
Exponents & Logarithms#
pow#
pow eleva x a la potencia de y y devuelve un valor flotante, incluso si ambas entradas son números enteros.
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)
robot.screen.print(power_result)
# power_result = 8.00
sqrt#
sqrt calcula la raíz cuadrada de un número y devuelve un valor flotante, incluso para cuadrados perfectos.
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)
robot.screen.print(sqrt_result)
# sqrt_result = 4.00
exp#
exp calcula la exponencial de un número y devuelve un flotante.
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)
robot.screen.print(exp_result)
# exp_result = 2.72
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)
robot.screen.print(log_result)
# log_result = 2.00
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)
robot.screen.print(log10_result)
# log10_result = 3.00
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)
robot.screen.print(log2_result)
# log2_result = 3.00
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)
robot.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)
robot.screen.print(expm1_result)
# expm1_result = 1.72
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)
robot.screen.print(fractional_part)
robot.screen.next_row()
robot.screen.print(integer_part)
# fractional_part = 0.14
# integer_part = 3.00
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)
robot.screen.print(mantissa)
robot.screen.next_row()
robot.screen.print(exponent)
# mantissa = 0.50
# 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)
robot.screen.print(fmod_result)
# fmod_result = 1.00
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)
robot.screen.print(copysign_result)
# copysign_result = 10.00
ldexp#
ldexp calcula x * (2 ** exp), que es equivalente a x * 2exp{code}.
Usage:
math.ldexp(x, exp)
Parámetro |
Descripción |
|---|---|
|
El valor base. |
|
El exponente. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
robot.screen.print(ldexp_result)
# ldexp_result = 48.00
Comparison & Approximation#
isclose#
isclose comprueba si dos números son aproximadamente iguales dentro de una tolerancia.
Usage:
math.isclose(a, b, rel_tol, abs_tol)
Parámetro |
Descripción |
|---|---|
|
El primer número a comparar. |
|
El segundo número a comparar. |
|
Opcional. La diferencia máxima permitida entre a y b, en relación con su tamaño. El valor predeterminado es 1e-09 (muy pequeño). |
|
Opcional. Un margen de error fijo, útil cuando se comparan números cercanos a cero. El valor predeterminado es 0.0. |
Nota: Si se proporcionan rel_tol y abs_tol tol, la condición que se cumpla primero determinará el resultado.
# Check if 1.000000001 and 1.0 are close
# within the default tolerance
isclose_result = math.isclose(1.000000001, 1.0)
robot.screen.print(isclose_result)
# isclose_result = True
# Check if 0.0000001 and 0.0 are close
# using absolute tolerance
isclose_result = math.isclose(0.0000001, 0.0, abs_tol=1e-07)
robot.screen.print(isclose_result)
# isclose_result = True
# Check if 1000000.0 and 1000000.1 are close
# with a stricter tolerance
isclose_result = math.isclose(1000000.0, 1000000.1, rel_tol=1e-10)
robot.screen.print(isclose_result)
# isclose_result = False
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)
robot.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)
robot.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)
robot.screen.print(is_inf_true)
# is_inf_true = True
# Check if 42 is an infinite number (returns False)
is_inf_false = math.isinf(42)
robot.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)
robot.screen.print(is_nan_true)
# is_nan_true = True
# Check if 42 is NaN (returns False)
is_nan_false = math.isnan(42)
robot.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)
robot.screen.print(gamma_result)
# gamma_result = 24.00
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)
robot.screen.print(lgamma_result)
# lgamma_result = 3.18
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)
robot.screen.print(erf_result)
# erf_result = 0.84
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)
robot.screen.print(erfc_result)
# erfc_result = 0.16