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 – Computes x * (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

x

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

x

Un número entero o flotante.

ndigits

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

arg1, arg2, …

Los números para comparar.

sequence

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

arg1, arg2, …

Los números para comparar.

sequence

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

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.

 
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

a

El dividendo.

b

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

x

El número base.

y

El exponente.

mod

Opcional. Un valor de módulo. Si se proporciona, devuelve (x ** y) % mod.

 
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

x

Un número, cadena u otro objeto para convertir.

base

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

x

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

x

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

x

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

x

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

x

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

x

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

y

Un número flotante o entero que representa la coordenada y.

x

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

x

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

x

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

x

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

x

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

x

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

x

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

x

Un número entero o flotante positivo.

base

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

x

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

x

Una base de número flotante o entero.

y

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

x

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

x

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

x

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

x

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

x

El dividendo.

y

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

x

El valor a modificar.

y

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

x

El valor base.

exp

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)
En esta página