Matemática#

Introdução #

O módulo Math inclui funções nativas do Python e o módulo math , que está automaticamente disponível no VEXcode GO. Estas ferramentas permitem realizar desde operações aritméticas básicas até trigonometria avançada, arredondamento e operações logarítmicas.

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 – Calcula o logaritmo de x.
math.log10 – Calcula o logaritmo de base 10 de x.

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)
    console.print(abs_result)

# abs_result = 10

# Start threads — Do not delete
start_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)
    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 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)
    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 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)
    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 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])
    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 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)
    console.print(divmod_result)

# divmod_result = (3, 1)

# Start threads — Do not delete
start_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)
    console.print(pow_result)

# pow_result = 8

# Start threads — Do not delete
start_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)
    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)

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.

# Convert division result to a float
num_apples = 6
num_people = 2
apples_per_person = float(num_apples) / num_people
robot.screen.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)
robot.screen.print(user_number * 3)

# Output: 70.20

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
    console.print(circle_area, precision=2)

# circle_area = 78.54

# Start threads — Do not delete
start_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
    console.print(circumference, precision=2)

# circumference = 31.42

# Start threads — Do not delete
start_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)
    console.print(e_power, precision=2)

# e_power = 7.39

# Start threads — Do not delete
start_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))
    console.print(result, precision=2)

# result = 0.50

# Start threads — Do not delete
start_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))
    console.print(result, precision=2)

# result = 0.50

# Start threads — Do not delete
start_thread(main)

bronzeado #

A função tan calcula a tangente de um ângulo em radianos e devolve um número inteiro.

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))
    console.print(result)

# result = 1

# Start threads — Do not delete
start_thread(main)

asin #

asin calcula o seno inverso (arco seno) de um número e devolve um número inteiro 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))
    console.print(result)

# result = 30

# Start threads — Do not delete
start_thread(main)

acos #

acos calcula o arco coseno (cosseno inverso) de um número e devolve um número inteiro 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))
    console.print(result)

# result = 60

# Start threads — Do not delete
start_thread(main)

atan #

atan calcula a tangente inversa (arco tangente) de um número e devolve um número inteiro 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)
    console.print(result)

# result = 45

# Start threads — Do not delete
start_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)
    console.print(result)

# result = 45

# Start threads — Do not delete
start_thread(main)

graus #

degrees converte um ângulo de radianos para graus e devolve um número inteiro.

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)
    console.print(degrees_result)

# degrees_result = 180

# Start threads — Do not delete
start_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)
    console.print(radians_result, precision=2)

# radians_result = 3.14

# Start threads — Do not delete
start_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)
    console.print(ceil_result)

# ceil_result = 4

# Start threads — Do not delete
start_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)
    console.print(floor_result)

# floor_result = 3

# Start threads — Do not delete
start_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)
    console.print(trunc_result)

# trunc_result = 3

# Start threads — Do not delete
start_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)
    console.print(fabs_result, precision=1)

# fabs_result = 3.7

# Start threads — Do not delete
start_thread(main)

Exponents & Logarithms #

registo #

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

Usage:
math.log(x, base)

Parâmetro	Descrição
`x`	Um número de ponto flutuante ou inteiro positivo.
`base`	Opcional. A base do logaritmo a utilizar. Por defeito, é o 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)

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

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)
    console.print(power_result)

    # power_result = 8

# Start threads — Do not delete
start_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 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 #

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)
    console.print(exp_result, precision=2)

# exp_result = 2.72

# Start threads — Do not delete
start_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)
    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 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)
    console.print(mantissa, precision=2)
    console.new_line()
    console.print(exponent)

# mantissa = 0.50
# exponent = 5

# Start threads — Do not delete
start_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)
    console.print(fmod_result)

# fmod_result = 1

# Start threads — Do not delete
start_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)
    console.print(copysign_result)

# copysign_result = 10

# Start threads — Do not delete
start_thread(main)

ldexp #

ldexp calcula x * (2 ** exp), que é equivalente a x * 2^exp.

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)
    console.print(ldexp_result)

# ldexp_result = 48

# Start threads — Do not delete
start_thread(main)