Matemáticas#

Introducción #

Math includes both built-in Python functions and the full math module, which is automatically available in VEXcode EXP. These tools allow you to perform everything from basic arithmetic to advanced trigonometry, rounding, and logarithmic operations.

Utiliza estas funciones y constantes para calcular posiciones, ángulos, distancias y otros valores numéricos para tu 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 las funciones matemáticas, constantes y utilidades disponibles:

Funciones integradas: herramientas matemáticas comunes incluidas en Python.

abs – Returns the absolute value of a number.
round – Rounds a number to a specified number of decimal places.
min – Returns the smallest of the input values.
max – Returns the largest of the input values.
sum – Adds up all values in an iterable.
divmod – Returns the quotient and remainder as a tuple.
pow – Raises a number to a power, optionally with a modulus.
int – Converts a value to an integer.
float – Converts a value to a floating-point number.

Constants – Predefined values from the math module.

math.pi – The constant π (pi).
math.e – Euler’s number, base of the natural log.

Trigonometría: Calcular ángulos y relaciones entre lados.

math.sin – Sine of an angle in radians.
math.cos – Cosine of an angle in radians.
math.tan – Tangent of an angle in radians.
math.atan – Arctangent of a value in radians.
math.atan2 – Arctangent of y/x in radians, considering the quadrant.
math.asin – Arcsine of a value in radians.
math.acos – Arccosine of a value in radians.
math.degrees – Converts radians to degrees.
math.radians – Converts degrees to radians.

Redondeo y valor absoluto: ajuste la precisión o la dirección.

math.ceil – Rounds up to the nearest integer.
math.floor – Rounds down to the nearest integer.
math.trunc – Removes the decimal portion.
math.fabs – Returns the absolute value as a float.

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

math.pow – Raises a number to a power.
math.sqrt – Returns the square root.
math.exp – Calculates e to the power of x.
math.log – Calculate the logarithm of x.

Operaciones con números de coma flotante: Inspeccione o descomponga valores de coma flotante.

math.modf – Returns the fractional and integer parts of a float.
math.frexp – Decomposes a number into mantissa and exponent.
math.fmod – Remainder with sign of the dividend.
math.copysign – Returns a value with the sign of another.
math.ldexp – Computes x * (2 ** exp).

Funciones integradas #

Python proporciona varias funciones integradas que permiten realizar operaciones matemáticas dentro de tu proyecto.

abs #

abs returns the absolute value of a number, removing any negative sign.

Usage:
abs(x)

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

# Get the absolute value of -10
abs_result = abs(-10)
brain.print(abs_result)

# abs_result = 10

round #

round rounds a number to a specified number of decimal places.

Usage:
round(x, ndigits)

Parámetro	Descripción
`x`	Un número entero o decimal.
`ndigits`	Opcional. Número de decimales a los que redondear. El valor predeterminado es 0.

# Round 5.7 to the nearest integer
round_int_result = round(5.7)
brain.print(round_int_result)

# round_int_result = 6

# Round 3.14159 to 2 decimal places
round_result = round(3.14159, 2)
brain.print(round_result, precision=2)

# round_result = 3.14

min #

min returns the smallest value from multiple arguments or an iterable.

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

Parámetro	Descripción
`arg1`, `arg2`, …	Las cifras a comparar.
`sequence`	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)
brain.print(min_result)

# min_result = 1

# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
brain.print(min_list_result)

# min_list_result = 1

max #

max returns the largest value from multiple arguments or an iterable.

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

Parámetro	Descripción
`arg1`, `arg2`, …	Las cifras a comparar.
`sequence`	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)
brain.print(max_result)

# max_result = 7

# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
brain.print(max_list_result)

# max_list_result = 25

sum #

sum adds up all values in an iterable, with an optional starting value.

Usage:
sum(sequence, start)

Parámetro	Descripción
`sequence`	Una lista, tupla u otra secuencia que contenga 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])
brain.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)
brain.print(sum_with_start)

# sum_with_start = 16

divmod #

divmod returns a tuple containing the quotient and remainder of a division operation.

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)
brain.print(divmod_result)

# divmod_result = (3, 1)

pow #

pow raises a number to a power and optionally performs a modulus operation.

Usage:
pow(x, y, mod)

Parámetro	Descripción
`x`	El número base.
`y`	El exponente.
`mod`	Optional. A modulus value. If provided, returns `(x ** y) % mod`.

# Calculate 2 raised to the power of 3
pow_result = pow(2, 3)
brain.print(pow_result)

# pow_result = 8

int #

int converts a number or string into an integer. It also supports base conversion when converting from a string.

Usage:
int(x, base)

Parámetro	Descripción
`x`	Un número, cadena u otro objeto para convertir.
`base`	Opcional. La base numérica que se 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)
brain.print("{} coins".format(price_int))

# Output: 19 coins

# Convert a string into an integer to use in calculations
user_input = "55"
user_number = int(user_input)
brain.print(user_number * 2)

# Output: 110

float #

float converts a number or string into a floating-point number.

Usage:
float(x)

Parámetro	Descripción
`x`	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
brain.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)
brain.print(user_number * 3)

# Output: 70.20

Módulo de matemáticas #

The math module in MicroPython provides additional methods for performing common mathematical calculations. These methods include trigonometric, logarithmic, and other numerical operations.

The math module is imported by default in VEXcode.

Constants #

Las constantes son valores predefinidos que permanecen fijos durante un proyecto. Se pueden usar en cálculos sin necesidad de definirlos ni asignarles ningún valor.

pi #

pi gives the mathematical constant π, the ratio of a circle’s circumference to its diameter.

Usage:
math.pi

# Calculate the area of a circle with radius 5 using pi
circle_area = math.pi * 5 * 5
brain.print(circle_area, precision=2)

# circle_area = 78.54

mi #

e gives the base of the natural logarithm.

Usage:
math.e

# Calculate e raised to the power of 2
e_power = math.pow(math.e, 2)
brain.print(e_power, precision=2)

# e_power = 7.39

Trigonometry #

pecado #

sin calculates the sine of an angle in radians and returns a float.

Usage:
math.sin(x)

Parámetro	Descripción
`x`	Un número decimal o entero que representa un ángulo en radianes.

# Calculate the sine of 
# 30 degrees in radians
result = math.sin(math.radians(30))
brain.print(result, precision=2)

# result = 0.50

porque #

cos calculates the cosine of an angle in radians and returns a float.

Usage:
math.cos(x)

Parámetro	Descripción
`x`	Un número decimal o entero que representa un ángulo en radianes.

# Calculate the cosine of 
# 60 degrees in radians
result = math.cos(math.radians(60))
brain.print(result, precision=2)

# result = 0.50

broncearse #

tan calculates the tangent of an angle in radians and returns a float.

Usage:
math.tan(x)

Parámetro	Descripción
`x`	Un número decimal o entero que representa un ángulo en radianes.

# Calculate the tangent of 
# 45 degrees in radians
result = math.tan(math.radians(45))
brain.print(result)

# result = 1.00

asin #

asin calculates the inverse sine (arc sine) of a number and returns a float representing the angle in radians.

Usage:
math.asin(x)

Parámetro	Descripción
`x`	Un número decimal o entero entre -1 y 1.

# Calculate the arc sine 
# of 0.5 in degrees
result = math.degrees(math.asin(0.5))
brain.print(result)

# result = 30.00

acos #

acos calculates the inverse cosine (arc cosine) of a number and returns a float representing the angle in radians.

Usage:
math.acos(x)

Parámetro	Descripción
`x`	Un número decimal o entero entre -1 y 1.

# Calculate the arc cosine 
# of 0.5 in degrees
result = math.degrees(math.acos(0.5))
brain.print(result)

# result = 60.00

atan #

atan calculates the inverse tangent (arc tangent) of a number and returns a float representing the angle in radians.

Usage:
math.atan(x)

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

# Calculate the arc tangent 
# of 1 in degrees
arc_tan = math.atan(1.0)
result = math.degrees(arc_tan)
brain.print(result)

# result = 45.00

atan2 #

atan2 calculates the principal value of the inverse tangent of y/x and returns a float representing the angle in radians.

Usage:
math.atan2(y, x)

Parámetro	Descripción
`y`	Un número decimal o entero que representa la coordenada y.
`x`	Un número decimal o entero que representa la coordenada x.

# Calculate the inverse tangent 
# of 1/1 in degrees
atan2 = math.atan2(1.0, 1.0)
result = math.degrees(atan2)
brain.print(result)

# result = 45.00

títulos #

degrees converts an angle from radians to degrees and returns a float.

Usage:
math.degrees(x)

Parámetro	Descripción
`x`	Un número decimal o entero que representa un ángulo en radianes.

# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
brain.print(degrees_result)

# degrees_result = 180.00

radianes #

radians converts an angle from degrees to radians as a float.

Usage:
math.radians(x)

Parámetro	Descripción
`x`	Un valor decimal o entero que representa un ángulo en grados.

# Convert 180 degrees to radians
radians_result = math.radians(180)
brain.print(radians_result, precision=2)

# radians_result = 3.14

Rounding & Absolute Values #

fortificar techo #

ceil rounds a number up to the nearest integer.

Usage:
math.ceil(x)

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

# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
brain.print(ceil_result)

# ceil_result = 4

piso #

floor rounds a number down to the nearest integer.

Usage:
math.floor(x)

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

# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
brain.print(floor_result)

# floor_result = 3

truncamiento #

trunc removes the decimal part of a number without rounding.

Usage:
math.trunc(x)

Parámetro	Descripción
`x`	Un número flotante que se truncará.

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

# trunc_result = 3

fabs #

fabs returns the absolute value of a number as a float.

Usage:
math.fabs(x)

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

# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
brain.print(fabs_result, precision=1)

# fabs_result = 3.7

Exponents & Logarithms #

registro #

log calculates the logarithm of a number and returns a float.

Usage:
math.log(x, base)

Parámetro	Descripción
`x`	Un número decimal o entero positivo.
`base`	Opcional. La base del logaritmo que se utilizará. Por defecto, se utiliza el logaritmo natural.

# Calculate the natural logarithm
# (base e) of 7.389056
log_result = math.log(7.389056)
brain.print(log_result)

# log_result = 2.00

# Calculate the log base 2 of 8
log_result = math.log(8, 2)
brain.print(log_result)

# log_result = 3.00

¡Pum!#

pow raises x to the power of y and returns a float, even if both inputs are integers.

Usage:
math.pow(x, y)

Parámetro	Descripción
`x`	Una base de tipo flotante o entero.
`y`	Un exponente de tipo flotante o entero.

# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
brain.print(power_result)

# power_result = 8.00

raíz cuadrada #

sqrt calculates the square root of a number and returns a float, even for perfect squares.

Usage:
math.sqrt(x)

Parámetro	Descripción
`x`	Un número decimal o entero no negativo.

# Calculate the square root of 16
square_root = math.sqrt(16)
brain.print(square_root)

# square_root = 4.00

exp #

exp calculates the exponential of a number and returns a float.

Usage:
math.exp(x)

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

# Calculate e raised to the power of 1
exp_result = math.exp(1)
brain.print(exp_result, precision=2)

# exp_result = 2.72

Floating Point Operations #

modf #

modf decomposes a number into its fractional and integer parts and returns a tuple (fractional part, integer part), both as floats.

Usage:
math.modf(x)

Parámetro	Descripción
`x`	Un número decimal o entero para descomponer.

# Decompose 3.14159 into fractional and integer parts
fractional_part, integer_part = math.modf(3.14159)
brain.print(fractional_part, precision=2)

brain.print(integer_part)

# fractional_part = 0.14
# integer_part = 3

frexp #

frexp decomposes a number into its mantissa and exponent and returns a tuple (mantissa, exponent), where the mantissa is a float and the exponent is an integer.

Usage:
math.frexp(x)

Parámetro	Descripción
`x`	Un número decimal o entero para descomponer.

# Decompose 16 into its mantissa and exponent
mantissa, exponent = math.frexp(16)
brain.print(mantissa, precision=2)

brain.print(exponent)

# mantissa = 0.50
# exponent = 5

fmod #

fmod returns the remainder of division while keeping the sign of the dividend (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)
brain.print(fmod_result)

# fmod_result = 1

firmar por copia #

copysign returns x with the sign of 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)
brain.print(copysign_result)

# copysign_result = 10

ldexp #

ldexp computes x * (2 ** exp), which is equivalent to 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)
brain.print(ldexp_result)

# ldexp_result = 48