Matemáticas#
Introducción#
Math incluye funciones integradas de Python y el módulo completo math , disponible automáticamente en VEXcode GO. Estas herramientas permiten realizar todo tipo de operaciones, desde aritmética básica hasta trigonometría avanzada, redondeo y logaritmos.
Usa 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 funciones matemáticas, constantes y utilidades disponibles:
Funciones integradas: herramientas matemáticas comunes incluidas con 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.
Constantes: valores predefinidos del módulo math.
math.pi– The constant π (pi).math.tau– The constant tau (2π).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.math.log10– Calculates the base-10 logarithm of x.
Operaciones de punto flotante: inspeccionar o descomponer valores flotantes.
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– Computesx * (2 ** exp).
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.
Uso:
abs(x)
Parámetro |
Descripción |
|---|---|
|
Un número entero o flotante. |
def main():
# Get the absolute value of -10
abs_result = abs(-10)
console.print(abs_result)
# abs_result = 10
# Start threads — Do not delete
start_thread(main)
round#
round redondea un número a una cantidad específica de decimales.
Uso:
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. |
def main():
# Round 5.7 to the nearest integer
round_int_result = round(5.7)
console.print(round_int_result)
# round_int_result = 6
# Start threads — Do not delete
start_thread(main)
def main():
# Round 3.14159 to 2 decimal places
round_result = round(3.14159, 2)
console.print(round_result, precision=2)
# round_result = 3.14
# Start threads — Do not delete
start_thread(main)
min#
min devuelve el valor más pequeño de múltiples argumentos o un iterable.
Uso:
min(arg1, arg2, …) o min(sequence)
Parámetro |
Descripción |
|---|---|
|
Los números para comparar. |
|
Una lista, tupla u otra secuencia que contiene números. |
def main():
# Get the smallest number from 3, 7, and 1
min_result = min(3, 7, 1)
console.print(min_result)
# min_result = 1
# Start threads — Do not delete
start_thread(main)
def main():
# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
console.print(min_list_result)
# min_list_result = 1
# Start threads — Do not delete
start_thread(main)
max#
max devuelve el valor más grande de múltiples argumentos o un iterable.
Uso:
max(arg1, arg2, …) o max(sequence)
Parámetro |
Descripción |
|---|---|
|
Los números para comparar. |
|
Una lista, tupla u otra secuencia que contiene números. |
def main():
# Get the largest number from 3, 7, and 1
max_result = max(3, 7, 1)
console.print(max_result)
# max_result = 7
# Start threads — Do not delete
start_thread(main)
def main():
# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
console.print(max_list_result)
# max_list_result = 25
# Start threads — Do not delete
start_thread(main)
sum#
sum suma todos los valores en un iterable, con un valor inicial opcional.
Uso:
sum(sequence, start)
Parámetro |
Descripción |
|---|---|
|
Una lista, tupla u otra secuencia que contiene números. |
|
Opcional. Un valor para añadir a la suma. El valor predeterminado es 0. |
def main():
# Calculate the sum of a list of numbers
sum_result = sum([1, 2, 3, 4, 5])
console.print(sum_result)
# sum_result = 15
# Start threads — Do not delete
start_thread(main)
def main():
# Calculate the sum of a list with a starting value of 10
sum_with_start = sum([1, 2, 3], 10)
console.print(sum_with_start)
# sum_with_start = 16
# Start threads — Do not delete
start_thread(main)
divmod#
divmod devuelve una tupla que contiene el cociente y el resto de una operación de división.
Uso:
divmod(a, b)
Parámetro |
Descripción |
|---|---|
|
El dividendo. |
|
El divisor. |
def main():
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
console.print(divmod_result)
# divmod_result = (3, 1)
# Start threads — Do not delete
start_thread(main)
pow#
pow eleva un número a una potencia y opcionalmente realiza una operación de módulo.
Uso:
pow(x, y, mod)
Parámetro |
Descripción |
|---|---|
|
El número base. |
|
El exponente. |
|
Opcional. Un valor de módulo. Si se proporciona, devuelve |
def main():
# Calculate 2 raised to the power of 3
pow_result = pow(2, 3)
console.print(pow_result)
# pow_result = 8
# Start threads — Do not delete
start_thread(main)
int#
int convierte un número o cadena en un entero. También admite la conversión de base al convertir desde una cadena.
Uso:
int(x, base)
Parámetro |
Descripción |
|---|---|
|
Un número, cadena u otro objeto para convertir. |
|
Opcional. La base numérica que se usará para la conversión. El valor predeterminado es 10. |
def main():
# Convert a float to an integer to get rid of decimals
price = 19.99
price_int = int(price)
console.print("{} coins".format(price_int))
# Output: 19 coins
# Start threads — Do not delete
start_thread(main)
def main():
# Convert a string into an integer to use in calculations
user_input = "55"
user_number = int(user_input)
console.print(user_number * 2)
# Output: 110
# Start threads — Do not delete
start_thread(main)
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 de forma predeterminada 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 la constante matemática π, la relación entre la circunferencia de un círculo y su diámetro.
Uso:
math.pi
def main():
# Calculate the area of a circle with radius 5 using pi
circle_area = math.pi * 5 * 5
console.print(circle_area, precision=2)
# circle_area = 78.54
# Start threads — Do not delete
start_thread(main)
tau#
tau da el valor de 2π.
Uso:
math.tau
def main():
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
console.print(circumference, precision=2)
# circumference = 31.42
# Start threads — Do not delete
start_thread(main)
mi#
e da la base del logaritmo natural.
Uso:
math.e
def main():
# Calculate e raised to the power of 2
e_power = math.pow(math.e, 2)
console.print(e_power, precision=2)
# e_power = 7.39
# Start threads — Do not delete
start_thread(main)
Trigonometry#
pecado#
sin calcula el seno de un ángulo en radianes y devuelve un valor flotante.
Uso:
math.sin(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero que representa un ángulo en radianes. |
def main():
# Calculate the sine of
# 30 degrees in radians
result = math.sin(math.radians(30))
console.print(result, precision=2)
# result = 0.50
# Start threads — Do not delete
start_thread(main)
porque#
cos calcula el coseno de un ángulo en radianes y devuelve un valor flotante.
Uso:
math.cos(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero que representa un ángulo en radianes. |
def main():
# Calculate the cosine of
# 60 degrees in radians
result = math.cos(math.radians(60))
console.print(result, precision=2)
# result = 0.50
# Start threads — Do not delete
start_thread(main)
broncearse#
tan calculates the tangent of an angle in radians and returns an integer.
Uso:
math.tan(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero que representa un ángulo en radianes. |
def main():
# Calculate the tangent of
# 45 degrees in radians
result = math.tan(math.radians(45))
console.print(result)
# result = 1
# Start threads — Do not delete
start_thread(main)
asiático#
asin calculates the inverse sine (arc sine) of a number and returns an integer representing the angle in radians.
Uso:
math.asin(x)
Parámetro |
Descripción |
|---|---|
|
Un número flotante o entero entre -1 y 1. |
def main():
# Calculate the arc sine
# of 0.5 in degrees
result = math.degrees(math.asin(0.5))
console.print(result)
# result = 30
# Start threads — Do not delete
start_thread(main)
acos#
acos calculates the inverse cosine (arc cosine) of a number and returns an integer representing the angle in radians.
Uso:
math.acos(x)
Parámetro |
Descripción |
|---|---|
|
Un número flotante o entero entre -1 y 1. |
def main():
# Calculate the arc cosine
# of 0.5 in degrees
result = math.degrees(math.acos(0.5))
console.print(result)
# result = 60
# Start threads — Do not delete
start_thread(main)
Atán#
atan calculates the inverse tangent (arc tangent) of a number and returns an integer representing the angle in radians.
Uso:
math.atan(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero. |
def main():
# Calculate the arc tangent
# of 1 in degrees
arc_tan = math.atan(1.0)
result = math.degrees(arc_tan)
console.print(result)
# result = 45
# Start threads — Do not delete
start_thread(main)
atan2#
atan2 calcula el valor principal de la tangente inversa de y/x y devuelve un flotante que representa el ángulo en radianes.
Uso:
math.atan2(y, x)
Parámetro |
Descripción |
|---|---|
|
Un número flotante o entero que representa la coordenada y. |
|
Un número flotante o entero que representa la coordenada x. |
def main():
# Calculate the inverse tangent
# of 1/1 in degrees
atan2 = math.atan2(1.0, 1.0)
result = math.degrees(atan2)
console.print(result)
# result = 45
# Start threads — Do not delete
start_thread(main)
grados#
degrees converts an angle from radians to degrees and returns an integer.
Uso:
math.degrees(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero que representa un ángulo en radianes. |
def main():
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
console.print(degrees_result)
# degrees_result = 180
# Start threads — Do not delete
start_thread(main)
radianes#
radians convierte un ángulo de grados a radianes.
Uso:
math.radians(x)
Parámetro |
Descripción |
|---|---|
|
Un número flotante o entero que representa un ángulo en grados. |
def main():
# Convert 180 degrees to radians
radians_result = math.radians(180)
console.print(radians_result, precision=2)
# radians_result = 3.14
# Start threads — Do not delete
start_thread(main)
Rounding & Absolute Values#
fortificar techo#
ceil redondea un número al entero más cercano.
Uso:
math.ceil(x)
Parámetro |
Descripción |
|---|---|
|
Un número flotante o entero que se redondeará hacia arriba. |
def main():
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
console.print(ceil_result)
# ceil_result = 4
# Start threads — Do not delete
start_thread(main)
piso#
floor redondea un número hacia abajo hasta el entero más cercano.
Uso:
math.floor(x)
Parámetro |
Descripción |
|---|---|
|
Un número flotante o entero que se redondeará hacia abajo. |
def main():
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
console.print(floor_result)
# floor_result = 3
# Start threads — Do not delete
start_thread(main)
tronco#
trunc elimina la parte decimal de un número sin redondear.
Uso:
math.trunc(x)
Parámetro |
Descripción |
|---|---|
|
Un flotador que debe truncarse. |
def main():
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
console.print(trunc_result)
# trunc_result = 3
# Start threads — Do not delete
start_thread(main)
fábricas#
fabs devuelve el valor absoluto de un número como un flotante.
Uso:
math.fabs(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero. |
def main():
# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
console.print(fabs_result, precision=1)
# fabs_result = 3.7
# Start threads — Do not delete
start_thread(main)
Exponents & Logarithms#
registro#
log calcula el logaritmo de un número y devuelve un valor flotante.
Uso:
math.log(x, base)
Parámetro |
Descripción |
|---|---|
|
Un número entero o flotante positivo. |
|
Opcional. La base del logaritmo que se utilizará. Por defecto, es el logaritmo natural. |
def main():
# Calculate the natural logarithm
# (base e) of 7.389056
log_result = math.log(7.389056)
console.print(log_result)
# log_result = 2
# Start threads — Do not delete
start_thread(main)
def main():
# Calculate the log base 2 of 8
log_result = math.log(8, 2)
console.print(log_result)
# log_result = 3
# Start threads — Do not delete
start_thread(main)
registro10#
log10 calcula el logaritmo en base 10 de un número y devuelve un valor flotante.
Uso:
math.log10(x)
Parámetro |
Descripción |
|---|---|
|
Un número entero o flotante positivo. |
def main():
# Calculate the base-10 logarithm of 100
log10_result = math.log10(100)
console.print(log10_result)
# log10_result = 2
# Start threads — Do not delete
start_thread(main)
poder#
pow eleva x a la potencia de y y devuelve un punto flotante, incluso si ambas entradas son números enteros.
Uso:
math.pow(x, y)
Parámetro |
Descripción |
|---|---|
|
Una base de número flotante o entero. |
|
Un exponente flotante o entero. |
def main():
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
console.print(power_result)
# power_result = 8
# Start threads — Do not delete
start_thread(main)
raíz cuadrada#
sqrt calcula la raíz cuadrada de un número y devuelve un valor flotante, incluso para cuadrados perfectos.
Uso:
math.sqrt(x)
Parámetro |
Descripción |
|---|---|
|
Un número entero o flotante no negativo. |
def main():
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
console.print(power_result)
# power_result = 8
# Start threads — Do not delete
start_thread(main)
exp#
exp calcula el exponencial de un número y devuelve un flotante.
Uso:
math.exp(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero. |
def main():
# Calculate e raised to the power of 1
exp_result = math.exp(1)
console.print(exp_result, precision=2)
# exp_result = 2.72
# Start threads — Do not delete
start_thread(main)
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 flotantes.
Uso:
math.modf(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero para descomponer. |
def main():
# Decompose 3.14159 into fractional and integer parts
fractional_part, integer_part = math.modf(3.14159)
console.print(fractional_part, precision=2)
console.new_line()
console.print(integer_part)
# fractional_part = 0.14
# integer_part = 3
# Start threads — Do not delete
start_thread(main)
frexp#
frexp descompone un número en su mantisa y exponente y devuelve una tupla (mantissa, exponent), donde la mantisa es un número flotante y el exponente es un entero.
Uso:
math.frexp(x)
Parámetro |
Descripción |
|---|---|
|
Un flotante o entero para descomponer. |
def main():
# Decompose 16 into its mantissa and exponent
mantissa, exponent = math.frexp(16)
console.print(mantissa, precision=2)
console.new_line()
console.print(exponent)
# mantissa = 0.50
# exponent = 5
# Start threads — Do not delete
start_thread(main)
modo de funcionamiento#
fmod returns the remainder of division while keeping the sign of the dividend (x).
Uso:
math.fmod(x, y)
Parámetro |
Descripción |
|---|---|
|
El dividendo. |
|
El divisor. |
def main():
# Calculate remainder of 10 / 3
# that preserves the sign of 10
fmod_result = math.fmod(10, 3)
console.print(fmod_result)
# fmod_result = 1
# Start threads — Do not delete
start_thread(main)
firma de derechos de autor#
copysign devuelve x con el signo de y.
Uso:
math.copysign(x, y)
Parámetro |
Descripción |
|---|---|
|
El valor a modificar. |
|
El valor cuyo signo se copiará. |
def main():
# Return -10 with the sign of 3 (positive)
copysign_result = math.copysign(-10, 3)
console.print(copysign_result)
# copysign_result = 10
# Start threads — Do not delete
start_thread(main)
ldexp#
ldexp computes x * (2 ** exp), which is equivalent to x * 2exp.
Uso:
math.ldexp(x, exp)
Parámetro |
Descripción |
|---|---|
|
El valor base. |
|
El exponente. |
def main():
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
console.print(ldexp_result)
# ldexp_result = 48
# Start threads — Do not delete
start_thread(main)