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 puede convertir entre grados y radianes, evaluar expresiones y trabajar con valores especiales como infinito y NaN.

Nota: Salvo que se indique explícitamente lo contrario, todos los valores de retorno son números de coma flotante con un formato de cinco decimales. Los valores con más de cinco decimales se redondean, y los valores con menos de cinco decimales se amplían con ceros para que siempre se muestren exactamente cinco decimales.

A continuación se muestra una lista de funciones matemáticas, constantes y utilidades 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 lugares 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 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 logaritmo natural.
math.inf – Infinito positivo.
math.nan – No es un número (NaN).

Trigonometría – Calcular ángulos y relaciones entre 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 – Arcoseno de un valor en radianes.
math.acos – Arcocoseno 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 a grados.
math.radians – Convierte grados a radianes.

Hiperbólicas: funciones trigonométricas avanzadas.

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 entero más cercano.
math.floor – Redondea hacia abajo al entero más cercano.
math.trunc – Elimina la parte decimal.
math.fabs – Devuelve el valor absoluto como un número flotante.

Exponentes y logaritmos: cálculos de potencia, raíz y logaritmo.

math.pow – Eleva un número a una potencia.
math.sqrt – Devuelve la raíz cuadrada.
math.exp – Calcula e elevado a la potencia de x.
math.log – Logaritmo natural (base e).
math.log10 – Logaritmo en base 10.
math.log2 – Logaritmo en base 2.
math.factorial – Factorial de un número entero.
math.expm1 – Resultado más preciso para e^x - 1.

Operaciones de punto flotante: inspeccionar o descomponer valores flotantes.

math.modf – Devuelve las partes fraccionaria y entera de un float.
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 – Calcula x * (2 ** exp).

Comparación y aproximación: verifique 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
`x`	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 número entero.

Usage:
round(x, ndigits)

Parámetro	Descripción
`x`	Un número entero o flotante.
`ndigits`	Opcional. Controla a cuántos decimales redondear (entre 0 y 5). El valor predeterminado es 0. Cuando se utiliza este parámetro, `round` devuelve un número decimal.

# 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 múltiples argumentos o un iterable.

Usage:
min(arg1, arg2, …) or min(sequence)

Parámetro	Descripción
`arg1`, `arg2`, …	Los números para comparar.
`sequence`	Una lista, tupla u otra secuencia que contiene 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
`arg1`, `arg2`, …	Los números para comparar.
`sequence`	Una lista, tupla u otra secuencia que contiene 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 de un iterable, con un valor inicial opcional.

Usage:
sum(sequence, start)

Parámetro	Descripción
`sequence`	Una lista, tupla u otra secuencia que contiene números.
`start`	Opcional. Un valor para añadir 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
`a`	El dividendo.
`b`	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
`x`	El número base.
`y`	El exponente.
`mod`	Opcional. Un valor de módulo. Si se proporciona, devuelve `(x ** y) % mod`.

# 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 de base al convertir desde una cadena.

Usage:
int(x, base)

Parámetro	Descripción
`x`	Un número, una cadena u otro objeto para convertir.
`base`	Opcional. La base numérica que se usará 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
`x`	Un número, una 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. Pueden utilizarse en cálculos sin necesidad de definirlas ni asignarlas.

pi #

pi da como resultado 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

mi #

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

información #

inf da como resultado infinito positivo como un número de coma flotante.

Usage:
math.inf

# Check if infinity is infinite
inf_value = math.inf

if math.isinf(inf_value):
    controller.screen.print("Infinity")

# Prints "Infinity"

yaya #

nan representa un valor flotante especial para “No es un número” (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 #

pecado #

sin calcula el seno de un ángulo en radianes y devuelve un número decimal.

Usage:
math.sin(x)

Parámetro	Descripción
`x`	Un flotante o 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

porque #

cos calcula el coseno de un ángulo en radianes y devuelve un número decimal.

Usage:
math.cos(x)

Parámetro	Descripción
`x`	Un flotante o 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

broncearse #

tan calcula la tangente de un ángulo en radianes y devuelve un número decimal.

Usage:
math.tan(x)

Parámetro	Descripción
`x`	Un flotante o 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

asiático #

asin calcula el seno inverso (arco seno) de un número y devuelve un número flotante que representa el ángulo en radianes.

Usage:
math.asin(x)

Parámetro	Descripción
`x`	Un número 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 número flotante que representa el ángulo en radianes.

Usage:
>math.acos(x)

Parámetro	Descripción
`x`	Un número 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

Atán #

atan calcula la tangente inversa (tangente de arco) de un número y devuelve un número flotante que representa el ángulo en radianes.

Usage:
math.atan(x)

Parámetro	Descripción
`x`	Un flotante o 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 número flotante que representa el ángulo en radianes.

Usage:
math.atan2(y, x)

Parámetro	Descripción
`y`	Un flotante o entero que representa la coordenada y.
`x`	Un flotante o 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
`x`	Un flotante o 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
`x`	Un flotante o 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
`x`	Un flotante o 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

aporrear #

cosh calcula el coseno hiperbólico de x.

Usage:
math.cosh(x)

Parámetro	Descripción
`x`	Un flotante o 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
`x`	Un flotante o 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

asiático #

asinh calcula el seno hiperbólico inverso de x.

Usage:
math.asinh(x)

Parámetro	Descripción
`x`	Un flotante o 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
`x`	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
`x`	Un flotante 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 #

fortificar techo #

ceil redondea un número al entero más cercano.

Usage:
math.ceil(x)

Parámetro	Descripción
`x`	Un número flotante o entero que se redondeará hacia arriba.

# 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 hacia abajo al entero más cercano.

Usage:
math.floor(x)

Parámetro	Descripción
`x`	Un número flotante o 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

tronco #

trunc elimina la parte decimal de un número sin redondear.

Usage:
math.trunc(x)

Parámetro	Descripción
`x`	Un flotador que debe truncarse.

# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
controller.screen.print(trunc_result)

# trunc_result = 3

fábricas #

fabs devuelve el valor absoluto de un número como un número de coma flotante.

Usage:
math.fabs(x)

Parámetro	Descripción
`x`	Un flotante o 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 #

poder #

pow eleva x a la potencia de y (x^y) y devuelve un float.

Usage:
math.pow(x, y)

Parámetro	Descripción
`x`	Una base de número flotante o entero.
`y`	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

raíz cuadrada #

La función sqrt calcula la raíz cuadrada de un número y devuelve un número decimal.

Usage:
math.sqrt(x)

Parámetro	Descripción
`x`	Un número entero o flotante 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 (e^x) y como un float.

Usage:
math.exp(x)

Parámetro	Descripción
`x`	Un flotante o 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 número decimal.

Usage:
math.log(x)

Parámetro	Descripción
`x`	Un número entero o flotante 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

registro10 #

log10 calcula el logaritmo en base 10 de un número y devuelve un número flotante.

Usage:
math.log10(x)

Parámetro	Descripción
`x`	Un número entero o flotante positivo.

# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
controller.screen.print(log10_result)

# log10_result = 3.00000

registro2 #

log2 calcula el logaritmo en base 2 de un número y devuelve un número flotante, incluso cuando x es una potencia de 2.

Usage:
math.log2(x)

Parámetro	Descripción
`x`	Un número entero o flotante 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
`x`	Un entero no negativo.

# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
controller.screen.print(factorial_result)

# factorial_result = 120

expm1 #

expm1 calcula e^x - 1, que es más preciso para valores pequeños x.

Usage:
math.expm1(x)

Parámetro	Descripción
`x`	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), ambas como números de punto flotante.

Usage:
math.modf(x)

Parámetro	Descripción
`x`	Un flotante 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 float y el exponente es un entero.

Usage:
math.frexp(x)

Parámetro	Descripción
`x`	Un flotante 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
`x`	El dividendo.
`y`	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

firma de derechos de autor #

copysign devuelve x con el signo de y.

Usage:
math.copysign(x, y)

Parámetro	Descripción
`x`	El valor a modificar.
`y`	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 * 2^exp.

Usage:
math.ldexp(x, exp)

Parámetro	Descripción
`x`	El valor base.
`exp`	El exponente.

# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
controller.screen.print(ldexp_result)

# ldexp_result = 48.00000

Comparison & Approximation #

es finito #

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
`x`	Un flotante o entero para comprobar.

# 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

es inf #

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
`x`	Un flotante o entero para comprobar.

# 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
`x`	Un flotante o entero para comprobar.

# 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 #

gama #

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
`x`	Un número entero o flotante 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
`x`	Un número entero o flotante 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
`x`	Un flotante o 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
`x`	Un flotante o 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