Matemática#

Introdução#

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

Utilize estas funções e constantes para calcular posições, ângulos, distâncias e outros valores numéricos para o seu robô. Também pode converter entre graus e radianos, avaliar expressões e trabalhar com valores especiais como infinito e NaN.

Segue-se uma lista de funções matemáticas, constantes e utilitários disponíveis:

Funções integradas – Ferramentas matemáticas comuns incluídas no Python.

  • abs – Devolve o valor absoluto de um número.

  • round – Arredonda um número para um número especificado de casas decimais.

  • min – Devolve o menor dos valores de entrada.

  • max – Devolve o maior dos valores de entrada.

  • sum – Soma todos os valores num iterável.

  • divmod – Devolve o quociente e o resto como uma tupla.

  • pow – Eleva um número a uma potência, opcionalmente com um módulo.

  • int – Converte um valor num número inteiro.

  • float – Converte um valor para um número de ponto flutuante.

Constantes – Valores predefinidos do módulo de matemática math.

  • math.pi – A constante π (pi).

  • math.tau – A constante tau (2π).

  • math.e – Número de Euler, base do logaritmo natural.

Trigonometria – Calcular ângulos e relações entre os lados.

  • math.sin – Seno de um ângulo em radianos.

  • math.cos – Coseno de um ângulo em radianos.

  • math.tan – Tangente de um ângulo em radianos.

  • math.atan – Arco tangente de um valor em radianos.

  • math.atan2 – Arco tangente de y/x em radianos, considerando o quadrante.

  • math.asin – Arco seno de um valor em radianos.

  • math.acos – Arcocosseno de um valor em radianos.

  • math.degrees – Converte radianos em graus.

  • math.radians – Converte graus em radianos.

Arredondamento e valor absoluto – Ajuste a precisão ou a direção.

  • math.ceil – Arredonda para cima para o número inteiro mais próximo.

  • math.floor – Arredonda para baixo para o número inteiro mais próximo.

  • math.trunc – Remove a parte decimal.

  • math.fabs – Devolve o valor absoluto como um float.

Expoentes e Logaritmos – Cálculos de potência, raiz e logaritmo.

  • math.pow – Eleva um número a uma potência.

  • math.sqrt – Devolve a raiz quadrada.

  • math.exp – Calcula e elevado à potência de x.

  • math.log – Logaritmo natural (base e).

Operações com números de ponto flutuante – Inspecionar ou decompor valores de ponto flutuante.

  • math.modf – Devolve as partes fracionária e inteira de um float.

  • math.frexp – Decompõe um número em mantissa e expoente.

  • math.fmod – Resto com sinal do dividendo.

  • math.copysign – Devolve um valor com o sinal de outro.

  • math.ldexp – Calcula x * (2 ** exp).

Funções integradas#

O Python oferece diversas funções integradas que lhe permitem realizar operações matemáticas dentro do seu projeto.

abs#

abs devolve o valor absoluto de um número, removendo qualquer sinal negativo.

Usage:
abs(x)

Parâmetro

Descrição

x

Um número inteiro ou de ponto flutuante.

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

    # abs_result = 10

# VR threads — Do not delete
vr_thread(main)

round#

round arredondando um número para um número específico de casas decimais.

Usage:
round(x, ndigits)

Parâmetro

Descrição

x

Um número inteiro ou de ponto flutuante.

ndigits

Opcional. O número de casas decimais a arredondar. O predefinido é 0.

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

    # round_int_result = 6

# VR threads — Do not delete
vr_thread(main)


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

    # round_result = 3.14

# VR threads — Do not delete
vr_thread(main)

min#

min devolve o valor mais baixo entre múltiplos argumentos ou um iterável.

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

Parâmetro

Descrição

arg1, arg2, …

Os números a comparar.

sequence

Uma lista, tupla ou outra sequência que contenha números.

 
def main():
    # Get the smallest number from 3, 7, and 1
    min_result = min(3, 7, 1)
    brain.print(min_result)

    # min_result = 1

# VR threads — Do not delete
vr_thread(main)


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

    # min_list_result = 1

# VR threads — Do not delete
vr_thread(main)

max#

max devolve o maior valor entre múltiplos argumentos ou um iterável.

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

Parâmetro

Descrição

arg1, arg2, …

Os números a comparar.

sequence

Uma lista, tupla ou outra sequência que contenha números.

 
def main():
    # Get the largest number from 3, 7, and 1
    max_result = max(3, 7, 1)
    brain.print(max_result)

    # max_result = 7

# VR threads — Do not delete
vr_thread(main)


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

    # max_list_result = 25

# VR threads — Do not delete
vr_thread(main)

sum#

sum todos os valores num iterável, com um valor inicial opcional.

Usage:
sum(sequence, start)

Parâmetro

Descrição

sequence

Uma lista, tupla ou outra sequência que contenha números.

start

Opcional. Um valor a adicionar à soma. O predefinido é 0.

 
def main():
    # Calculate the sum of a list of numbers
    sum_result = sum([1, 2, 3, 4, 5])
    brain.print(sum_result)

    # sum_result = 15

# VR threads — Do not delete
vr_thread(main)


def main():
    # 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

# VR threads — Do not delete
vr_thread(main)

divmod#

divmod devolve uma tupla contendo o quociente e o resto de uma operação de divisão.

Usage:
divmod(a, b)

Parâmetro

Descrição

a

O dividendo.

b

O divisor.

 
def main():
    # Perform integer division and remainder of 10 / 3
    divmod_result = divmod(10, 3)
    brain.print(divmod_result)

    # divmod_result = (3, 1)

# VR threads — Do not delete
vr_thread(main)

pow#

pow eleva um número a uma potência e, opcionalmente, realiza uma operação de módulo.

Usage:
pow(x, y, mod)

Parâmetro

Descrição

x

O número base.

y

O expoente.

mod

Opcional. Um valor de módulo. Se for fornecido, devolve (x ** y) % mod.

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

    # pow_result = 8

# VR threads — Do not delete
vr_thread(main)

int#

int converte um número ou string num número inteiro. Também suporta a conversão de bases ao converter a partir de uma string.

Usage:
int(x, base)

Parâmetro

Descrição

x

Um número, uma sequência de caracteres ou outro objeto a converter.

base

Opcional. A base numérica a utilizar para a conversão. O padrão é 10.

 
def main():
    # 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

# VR threads — Do not delete
vr_thread(main)


def main():
    # 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

# VR threads — Do not delete
vr_thread(main)

float#

float converte um número ou string num número de ponto flutuante.

Usage:
float(x)

Parâmetro

Descrição

x

Um número, uma sequência de caracteres ou outro objeto a converter.

 
def main():
    # 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

# VR threads — Do not delete
vr_thread(main)


def main():
    # 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

# VR threads — Do not delete
vr_thread(main)

Módulo de Matemática#

O módulo math do MicroPython fornece métodos adicionais para realizar cálculos matemáticos comuns. Estes métodos incluem operações trigonométricas, logarítmicas e outras operações numéricas.

O módulo matemático math é importado por defeito no VEXcode.

Constants#

As constantes são valores predefinidos que permanecem fixos durante um projeto. Podem ser utilizadas em cálculos sem necessidade de definição ou atribuição.

pi#

pi fornece a constante matemática π, a razão entre a circunferência de um círculo e o seu diâmetro.

Usage:
math.pi

def main():
    # 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

# VR threads — Do not delete
vr_thread(main)

tau#

tau dá o valor de 2π.

Usage:
math.tau

def main():
    # Calculate the circumference of a circle with radius
    circumference = math.tau * 5
    brain.print(circumference, precision=2)

    # circumference = 31.42

# VR threads — Do not delete
vr_thread(main)

e#

e fornece a base do logaritmo natural.

Usage:
math.e

def main():
    # 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

# VR threads — Do not delete
vr_thread(main)

Trigonometry#

pecado#

A função sin calcula o seno de um ângulo em radianos e devolve um valor do tipo float.

Usage:
math.sin(x)

Parâmetro

Descrição

x

Um valor float ou inteiro que representa um ângulo em radianos.

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

    # result = 0.50

# VR threads — Do not delete
vr_thread(main)

cos#

A função cos calcula o coseno de um ângulo em radianos e devolve um valor do tipo float.

Usage:
math.cos(x)

Parâmetro

Descrição

x

Um valor float ou inteiro que representa um ângulo em radianos.

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

    # result = 0.50

# VR threads — Do not delete
vr_thread(main)

bronzeado#

A função tan calcula a tangente de um ângulo em radianos e devolve um valor float.

Usage:
math.tan(x)

Parâmetro

Descrição

x

Um valor float ou inteiro que representa um ângulo em radianos.

 
def main():
    # Calculate the tangent of 
    # 45 degrees in radians
    result = math.tan(math.radians(45))
    brain.print(result, precision=2)

    # result = 1.00

# VR threads — Do not delete
vr_thread(main)

atan#

atan calcula a tangente inversa (arco tangente) de um número e devolve um valor float que representa o ângulo em radianos.

Usage:
math.atan(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou um número inteiro.

 
def main():
    # Calculate the arc tangent 
    # of 1 in degrees
    arc_tan = math.atan(1.0)
    result = math.degrees(arc_tan)
    brain.print(result, precision=2)

    # result = 45.00

# VR threads — Do not delete
vr_thread(main)

atan2#

atan2 calcula o valor principal da tangente inversa de y/x e devolve um número de ponto flutuante que representa o ângulo em radianos.

Usage:
math.atan2(y, x)

Parâmetro

Descrição

y

Um número de ponto flutuante ou inteiro que representa a coordenada y.

x

Um número de ponto flutuante ou inteiro que representa a coordenada x.

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

    # result = 45.00

# VR threads — Do not delete
vr_thread(main)

asin#

asin calcula o seno inverso (arco seno) de um número e devolve um valor float que representa o ângulo em radianos.

Usage:
math.asin(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou inteiro entre -1 e 1.

 
def main():
    # Calculate the arc sine 
    # of 0.5 in degrees
    result = math.degrees(math.asin(0.5))
    brain.print(result, precision=2)

    # result = 30.00

# VR threads — Do not delete
vr_thread(main)

acos#

acos calcula o arco coseno (cosseno inverso) de um número e devolve um valor float que representa o ângulo em radianos.

Usage:
math.acos(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou inteiro entre -1 e 1.

 
def main():
    # Calculate the arc cosine 
    # of 0.5 in degrees
    result = math.degrees(math.acos(0.5))
    brain.print(result, precision=2)

    # result = 60.00

# VR threads — Do not delete
vr_thread(main)

graus#

degrees converte um ângulo de radianos para graus.

Usage:
math.degrees(x)

Parâmetro

Descrição

x

Um valor float ou inteiro que representa um ângulo em radianos.

 
def main():
    # Convert pi radians to degrees
    degrees_result = math.degrees(math.pi)
    brain.print(degrees_result, precision=2)

    # degrees_result = 180.00

# VR threads — Do not delete
vr_thread(main)

radianos#

radians converte um ângulo de graus em radianos.

Usage:
math.radians(x)

Parâmetro

Descrição

x

Um valor float ou inteiro que representa um ângulo em graus.

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

    # radians_result = 3.14

# VR threads — Do not delete
vr_thread(main)

Rounding & Absolute Values#

teto#

ceil arredonda um número para o número inteiro mais próximo.

Usage:
math.ceil(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou inteiro a ser arredondado para cima.

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

    # ceil_result = 4

# VR threads — Do not delete
vr_thread(main)

andar#

floor arredonda um número para baixo, para o número inteiro mais próximo.

Usage:
math.floor(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou inteiro a ser arredondado para baixo.

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

    # floor_result = 3

# VR threads — Do not delete
vr_thread(main)

truncar#

trunc remove a parte decimal de um número sem o arredondar.

Usage:
math.trunc(x)

Parâmetro

Descrição

x

Um número de ponto flutuante a ser truncado.

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

    # trunc_result = 3

# VR threads — Do not delete
vr_thread(main)

fabulosos#

fabs devolve o valor absoluto de um número como um número de ponto flutuante.

Usage:
math.fabs(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou um número inteiro.

 
def main():
    # Get the absolute value of -3.7
    fabs_result = math.fabs(-3.7)
    brain.print(fabs_result, precision=2)

    # fabs_result = 3.70

# VR threads — Do not delete
vr_thread(main)

Exponents & Logarithms#

prisioneiro de guerra#

pow eleva x à potência de y e devolve um número de ponto flutuante, mesmo que ambas as entradas sejam inteiros.

Usage:
math.pow(x, y)

Parâmetro

Descrição

x

Uma base de ponto flutuante ou inteira.

y

Um expoente de ponto flutuante ou inteiro.

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

    # power_result = 8.00

# VR threads — Do not delete
vr_thread(main)

raiz quadrada#

A função sqrt calcula a raiz quadrada de um número e devolve um valor float, mesmo para quadrados perfeitos.

Usage:
math.sqrt(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou inteiro não negativo.

 
def main():
    # Calculate the square root of 16
    sqrt_result = math.sqrt(16)
    brain.print(sqrt_result, precision=2)

    # sqrt_result = 4.00

# VR threads — Do not delete
vr_thread(main)

exp#

A função exp calcula a exponencial de um número e devolve um valor do tipo float.

Usage:
math.exp(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou um número inteiro.

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

    # exp_result = 2.72

# VR threads — Do not delete
vr_thread(main)

registo#

A função log calcula o logaritmo natural de um número e devolve um valor do tipo float.

Usage:
math.log(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou inteiro positivo.

 
def main():
    # Calculate the natural logarithm
    # (base e) of 7.389056
    log_result = math.log(7.389056)
    brain.print(log_result, precision=2)

    # log_result = 2.00

# VR threads — Do not delete
vr_thread(main)

log10#

log10 calcula o logaritmo na base 10 de um número e devolve um valor float.

Usage:
math.log10(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou inteiro positivo.

 
def main():
    # Calculate the log10 of 100
    log_result = math.log10(100)
    brain.print(log_result)

    # log_result = 2

# VR threads — Do not delete
vr_thread(main)

Floating Point Operations#

modf#

modf decompõe um número nas suas partes fracionária e inteira e devolve uma tupla (fractional part, integer part), ambas como flutuadores.

Usage:
math.modf(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou inteiro para decompor.

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

    # fractional_part = 0.14
    # integer_part = 3.00

# VR threads — Do not delete
vr_thread(main)

frexp#

frexp decompõe um número na sua mantissa e expoente e devolve uma tupla (mantissa, exponent), em que a mantissa é um float e o expoente é um número inteiro.

Usage:
math.frexp(x)

Parâmetro

Descrição

x

Um número de ponto flutuante ou inteiro para decompor.

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

    # mantissa = 0.50
    # exponent = 5

# VR threads — Do not delete
vr_thread(main)

fmod#

fmod devolve o resto da divisão, mantendo o sinal do dividendo (x).

Usage:
math.fmod(x, y)

Parâmetro

Descrição

x

O dividendo.

y

O divisor.

 
def main():
    # Calculate remainder of 10 / 3
    # that preserves the sign of 10
    fmod_result = math.fmod(10, 3)
    brain.print(fmod_result, precision=2)

    # fmod_result = 1.00

# VR threads — Do not delete
vr_thread(main)

copysign#

copysign devolve x com o sinal de y.

Usage:
math.copysign(x, y)

Parâmetro

Descrição

x

O valor a modificar.

y

O valor cujo sinal será copiado.

 
def main():
    # Return -10 with the sign of 3 (positive)
    copysign_result = math.copysign(-10, 3)
    brain.print(copysign_result, precision=2)

    # copysign_result = 10.00

# VR threads — Do not delete
vr_thread(main)

ldexp#

ldexp calcula x * (2 ** exp), que é equivalente a x * 2exp{code}.

Usage:
math.ldexp(x, exp)

Parâmetro

Descrição

x

O valor base.

exp

O expoente.

 
def main():
    # Compute 3 * (2 ** 4)
    ldexp_result = math.ldexp(3, 4)
    brain.print(ldexp_result, precision=2)

    # ldexp_result = 48.00

# VR threads — Do not delete
vr_thread(main)
On this page