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 AIM. 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.math.inf– Infinito positivo.math.nan– Não é um número (NaN).
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.
Hiperbólicos – Funções trigonométricas avançadas.
math.sinh– Seno hiperbólico de um valor.math.cosh– Coseno hiperbólico de um valor.math.tanh– Tangente hiperbólica de um valor.math.asinh– Seno hiperbólico inverso.math.acosh– Coseno hiperbólico inverso.math.atanh– Tangente hiperbólica inversa.
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).math.log10– Logaritmo de base 10.math.log2– Logaritmo de base 2.math.factorial– Factorial de um número inteiro.math.expm1– Resultado mais preciso parae^x - 1.
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– Calculax * (2 ** exp).
Comparação e Aproximação – Verifique os valores com tolerâncias ou categorias.
math.isclose– Testa se dois valores são aproximadamente iguais.math.isfinite– Verifica se um número é finito.math.isinf– Verifica se um número é infinito.math.isnan– Verifica se um valor é NaN.
Erro e Gama – Funções matemáticas especiais.
math.gamma– Função Gama (factorial generalizado).math.lgamma– Gama logarítmica.math.erf– Função de erro.math.erfc– Função de erro complementar.
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 |
|---|---|
|
Um número inteiro ou de ponto flutuante. |
# Get the absolute value of -10
abs_result = abs(-10)
robot.screen.print(abs_result)
# abs_result = 10
round#
round arredondando um número para um número específico de casas decimais.
Usage:
round(x, ndigits)
Parâmetro |
Descrição |
|---|---|
|
Um número inteiro ou de ponto flutuante. |
|
Opcional. O número de casas decimais a arredondar. O predefinido é 0. |
# Round 5.7 to the nearest integer
round_int_result = round(5.7)
robot.screen.print(round_int_result)
# round_int_result = 6
# Round 3.14159 to 2 decimal places
round_result = round(3.14159, 2)
robot.screen.print(round_result)
# round_result = 3.14
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 |
|---|---|
|
Os números a comparar. |
|
Uma lista, tupla ou outra sequência que contenha números. |
# Get the smallest number from 3, 7, and 1
min_result = min(3, 7, 1)
robot.screen.print(min_result)
# min_result = 1
# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
robot.screen.print(min_list_result)
# min_list_result = 1
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 |
|---|---|
|
Os números a comparar. |
|
Uma lista, tupla ou outra sequência que contenha números. |
# Get the largest number from 3, 7, and 1
max_result = max(3, 7, 1)
robot.screen.print(max_result)
# max_result = 7
# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
robot.screen.print(max_list_result)
# max_list_result = 25
sum#
sum todos os valores num iterável, com um valor inicial opcional.
Usage:
sum(sequence, start)
Parâmetro |
Descrição |
|---|---|
|
Uma lista, tupla ou outra sequência que contenha números. |
|
Opcional. Um valor a adicionar à soma. O predefinido é 0. |
# Calculate the sum of a list of numbers
sum_result = sum([1, 2, 3, 4, 5])
robot.screen.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)
robot.screen.print(sum_with_start)
# sum_with_start = 16
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 |
|---|---|
|
O dividendo. |
|
O divisor. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
robot.screen.print(divmod_result)
# divmod_result = (3, 1)
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 |
|---|---|
|
O número base. |
|
O expoente. |
|
Opcional. Um valor de módulo. Se for fornecido, devolve |
# Calculate 2 raised to the power of 3
pow_result = pow(2, 3)
robot.screen.print(pow_result)
# pow_result = 8
# Calculate (5 ** 3) % 7
pow_mod_result = pow(5, 3, 7)
robot.screen.print(pow_mod_result)
# pow_mod_result = 6
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 |
|---|---|
|
Um número, uma sequência de caracteres ou outro objeto a converter. |
|
Opcional. A base numérica a utilizar para a conversão. O padrão é 10. |
# Convert a float to an integer to get rid of decimals
price = 19.99
price_int = int(price)
robot.screen.print(f"{price_int} coins")
# Output: 19 coins
# Convert a string into an integer to use in calculations
user_input = "55"
user_number = int(user_input)
robot.screen.print(user_number * 2)
# Output: 110
float#
float converte um número ou string num número de ponto flutuante.
Usage:
float(x)
Parâmetro |
Descrição |
|---|---|
|
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
# Calculate the area of a circle with radius 5 using pi
circle_area = math.pi * 5 * 5
robot.screen.print(circle_area)
# circle_area = 78.54
tau#
tau dá o valor de 2π.
Usage:
math.tau
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
robot.screen.print(circumference)
# circumference = 31.42
e#
e fornece a base do logaritmo natural.
Usage:
math.e
# Calculate e raised to the power of 2
e_power = math.pow(math.e, 2)
robot.screen.print(e_power)
# e_power = 7.39
informação#
inf resulta no infinito positivo como um número de ponto flutuante.
Usage:
math.inf
# Check if infinity is infinite
inf_value = math.inf
if math.isinf(inf_value):
robot.screen.print("Infinity")
# Prints "Infinity"
nan#
nan representa um número de ponto flutuante especial para “Não é um Número” (NaN).
Usage:
math.nan
# Check if nan is Not a Number
nan_value = math.nan
if math.isnan(nan_value):
robot.screen.print("Not a Number")
# Prints "Not a Number"
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 |
|---|---|
|
Um valor float ou inteiro que representa um ângulo em radianos. |
# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
robot.screen.print(sine_result)
# sine_result = 0.50
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 |
|---|---|
|
Um valor float ou inteiro que representa um ângulo em radianos. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
robot.screen.print(cosine_result)
# cosine_result = 0.50
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 |
|---|---|
|
Um valor float ou inteiro que representa um ângulo em radianos. |
# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
robot.screen.print(tangent_result)
# tangent_result = 1.00
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 |
|---|---|
|
Um número de ponto flutuante ou um número inteiro. |
# Calculate the arc tangent of 1 in degrees
arc_tangent_result = math.degrees(math.atan(1.0))
robot.screen.print(arc_tangent_result)
# arc_tangent_result = 45.00
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 |
|---|---|
|
Um número de ponto flutuante ou inteiro que representa a coordenada y. |
|
Um número de ponto flutuante ou inteiro que representa a coordenada x. |
# Calculate the inverse tangent of 1/1 in degrees
atan2_result = math.degrees(math.atan2(1.0, 1.0))
robot.screen.print(atan2_result)
# atan2_result = 45.00
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 |
|---|---|
|
Um número de ponto flutuante ou inteiro entre -1 e 1. |
# Calculate the arc sine of 0.5 in degrees
arc_sine_result = math.degrees(math.asin(0.5))
robot.screen.print(arc_sine_result)
# arc_sine_result = 30.00
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 |
|---|---|
|
Um número de ponto flutuante ou inteiro entre -1 e 1. |
# Calculate the arc cosine of 0.5 in degrees
arc_cosine_result = math.degrees(math.acos(0.5))
robot.screen.print(arc_cosine_result)
# arc_cosine_result = 60.00
graus#
degrees converte um ângulo de radianos para graus.
Usage:
math.degrees(x)
Parâmetro |
Descrição |
|---|---|
|
Um valor float ou inteiro que representa um ângulo em radianos. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
robot.screen.print(degrees_result)
# degrees_result = 180.00
radianos#
radians converte um ângulo de graus em radianos.
Usage:
math.radians(x)
Parâmetro |
Descrição |
|---|---|
|
Um valor float ou inteiro que representa um ângulo em graus. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
robot.screen.print(radians_result)
# radians_result = 3.14
Hyperbolics#
sinh#
sinh calcula o seno hiperbólico de x.
Usage:
math.sinh(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro que representa o valor de entrada. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
robot.screen.print(sinh_result)
# sinh_result = 1.18
cosh#
cosh calcula o coseno hiperbólico de x.
Usage:
math.cosh(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro que representa o valor de entrada. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
robot.screen.print(cosh_result)
# cosh_result = 1.54
tanh#
tanh calcula a tangente hiperbólica de x.
Usage:
math.tanh(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro que representa o valor de entrada. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
robot.screen.print(tanh_result)
# tanh_result = 0.76
asinh#
asinh calcula o seno inverso hiperbólico de x.
Usage:
math.asinh(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro que representa o valor de entrada. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
robot.screen.print(asinh_result)
# asinh_result = 0.88
acosh#
acosh calcula o coseno hiperbólico inverso de x.
Usage:
math.acosh(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro maior ou igual a 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
robot.screen.print(acosh_result)
# acosh_result = 1.32
atanh#
atanh calcula a tangente hiperbólica inversa de x.
Usage:
math.atanh(x)
Parâmetro |
Descrição |
|---|---|
|
Um número decimal entre -1 e 1 (exclusivo). |
# Calculate the inverse hyperbolic tangent of 0.5
atanh_result = math.atanh(0.5)
robot.screen.print(atanh_result)
# atanh_result = 0.55
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 |
|---|---|
|
Um número de ponto flutuante ou inteiro a ser arredondado para cima. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
robot.screen.print(ceil_result)
# ceil_result = 4
andar#
floor arredonda um número para baixo, para o número inteiro mais próximo.
Usage:
math.floor(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro a ser arredondado para baixo. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
robot.screen.print(floor_result)
# floor_result = 3
truncar#
trunc remove a parte decimal de um número sem o arredondar.
Usage:
math.trunc(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante a ser truncado. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
robot.screen.print(trunc_result)
# trunc_result = 3
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 |
|---|---|
|
Um número de ponto flutuante ou um número inteiro. |
# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
robot.screen.print(fabs_result)
# fabs_result = 3.70
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 |
|---|---|
|
Uma base de ponto flutuante ou inteira. |
|
Um expoente de ponto flutuante ou inteiro. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
robot.screen.print(power_result)
# power_result = 8.00
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 |
|---|---|
|
Um número de ponto flutuante ou inteiro não negativo. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
robot.screen.print(sqrt_result)
# sqrt_result = 4.00
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 |
|---|---|
|
Um número de ponto flutuante ou um número inteiro. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
robot.screen.print(exp_result)
# exp_result = 2.72
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 |
|---|---|
|
Um número de ponto flutuante ou inteiro positivo. |
# Calculate the natural logarithm (base e) of 7.389056
log_result = math.log(7.389056)
robot.screen.print(log_result)
# log_result = 2.00
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 |
|---|---|
|
Um número de ponto flutuante ou inteiro positivo. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
robot.screen.print(log10_result)
# log10_result = 3.00
log2#
A função log2 calcula o logaritmo na base 2 de um número e devolve um valor float, mesmo quando x é uma potência de 2.
Usage:
math.log2(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro positivo. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
robot.screen.print(log2_result)
# log2_result = 3.00
fatorial#
factorial devolve o fatorial de um número inteiro x, que é o produto de todos os números inteiros positivos até x.
Usage:
math.factorial(x)
Parâmetro |
Descrição |
|---|---|
|
Um número inteiro não negativo. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
robot.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 calcula ex - 1, que é mais preciso para x pequeno .
Usage:
math.expm1(x)
Parâmetro |
Descrição |
|---|---|
|
O valor do expoente. |
# Compute expm1(1) (e^1 - 1)
expm1_result = math.expm1(1)
robot.screen.print(expm1_result)
# expm1_result = 1.72
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 |
|---|---|
|
Um número de ponto flutuante ou inteiro para decompor. |
# Decompose 3.14159 into fractional and integer parts
fractional_part, integer_part = math.modf(3.14159)
robot.screen.print(fractional_part)
robot.screen.next_row()
robot.screen.print(integer_part)
# fractional_part = 0.14
# integer_part = 3.00
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 |
|---|---|
|
Um número de ponto flutuante ou inteiro para decompor. |
# Decompose 16 into its mantissa and exponent
mantissa, exponent = math.frexp(16)
robot.screen.print(mantissa)
robot.screen.next_row()
robot.screen.print(exponent)
# mantissa = 0.50
# exponent = 5
fmod#
fmod devolve o resto da divisão, mantendo o sinal do dividendo (x).
Usage:
math.fmod(x, y)
Parâmetro |
Descrição |
|---|---|
|
O dividendo. |
|
O divisor. |
# Calculate remainder of 10 / 3
# that preserves the sign of 10
fmod_result = math.fmod(10, 3)
robot.screen.print(fmod_result)
# fmod_result = 1.00
copysign#
copysign devolve x com o sinal de y.
Usage:
math.copysign(x, y)
Parâmetro |
Descrição |
|---|---|
|
O valor a modificar. |
|
O valor cujo sinal será copiado. |
# Return -10 with the sign of 3 (positive)
copysign_result = math.copysign(-10, 3)
robot.screen.print(copysign_result)
# copysign_result = 10.00
ldexp#
ldexp calcula x * (2 ** exp), que é equivalente a x * 2exp{code}.
Usage:
math.ldexp(x, exp)
Parâmetro |
Descrição |
|---|---|
|
O valor base. |
|
O expoente. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
robot.screen.print(ldexp_result)
# ldexp_result = 48.00
Comparison & Approximation#
está perto#
isclose verifica se dois números são aproximadamente iguais dentro de uma tolerância.
Usage:
math.isclose(a, b, rel_tol, abs_tol)
Parâmetro |
Descrição |
|---|---|
|
O primeiro número a ser comparado. |
|
O segundo número a comparar. |
|
Opcional. A diferença máxima permitida entre a e b, em relação ao seu tamanho. O valor predefinido é 1e-09 (muito pequeno). |
|
Opcional. Uma margem de erro fixa, útil quando se comparam números próximos de zero. O predefinido é 0,0. |
Nota: Se forem fornecidos os valores rel_tol e abs_tol , o resultado será determinado pela condição que for satisfeita em primeiro lugar.
# Check if 1.000000001 and 1.0 are close
# within the default tolerance
isclose_result = math.isclose(1.000000001, 1.0)
robot.screen.print(isclose_result)
# isclose_result = True
# Check if 0.0000001 and 0.0 are close
# using absolute tolerance
isclose_result = math.isclose(0.0000001, 0.0, abs_tol=1e-07)
robot.screen.print(isclose_result)
# isclose_result = True
# Check if 1000000.0 and 1000000.1 are close
# with a stricter tolerance
isclose_result = math.isclose(1000000.0, 1000000.1, rel_tol=1e-10)
robot.screen.print(isclose_result)
# isclose_result = False
é finito#
isfinite verifica se um número é finito. Este método retorna um valor booleano:
True– O número é finito.False– O número é infinito.
Usage:
math.isfinite(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro a verificar. |
# Check if 42 is a finite number (returns True)
is_finite_true = math.isfinite(42)
robot.screen.print(is_finite_true)
# is_finite_true = True
# Check if infinity is a finite number (returns False)
is_finite_false = math.isfinite(math.inf)
robot.screen.print(is_finite_false)
# is_finite_false = False
é inf#
O método isinf verifica se um número é infinito isinf e devolve um valor booleano (1).
True– O número é infinito.False– O número é finito.
Usage:
math.isinf(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro a verificar. |
# Check if infinity is an infinite number (returns True)
is_inf_true = math.isinf(math.inf)
robot.screen.print(is_inf_true)
# is_inf_true = True
# Check if 42 is an infinite number (returns False)
is_inf_false = math.isinf(42)
robot.screen.print(is_inf_false)
# is_inf_false = False
isnan#
O método isnan verifica se um número é NaN (Não é um Número). Este método retorna um valor booleano.
True– O número é NaN.False– O número é um número válido.
Usage:
math.isnan(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro a verificar. |
# Check if NaN (Not a Number) is NaN (returns True)
is_nan_true = math.isnan(math.nan)
robot.screen.print(is_nan_true)
# is_nan_true = True
# Check if 42 is NaN (returns False)
is_nan_false = math.isnan(42)
robot.screen.print(is_nan_false)
# is_nan_false = False
Error and Gamma Calculations#
gama#
gamma calcula a função gama de x, que generaliza a função factorial para números reais e complexos. Para um número inteiro n, gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro positivo. |
# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
robot.screen.print(gamma_result)
# gamma_result = 24.00
lgama#
lgamma calcula o logaritmo natural da função gamma.
Usage:
math.lgamma(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro positivo. |
# Calculate the natural logarithm of the
# gamma function of 5
lgamma_result = math.lgamma(5)
robot.screen.print(lgamma_result)
# lgamma_result = 3.18
terreno#
erf calcula a função de erro de x.
Usage:
math.erf(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro que representa o valor de entrada. |
# Calculate the error function of 1
erf_result = math.erf(1)
robot.screen.print(erf_result)
# erf_result = 0.84
erfc#
erfc calcula a função de erro complementar de x, que é definida como 1 - erf(x).
Usage:
math.erfc(x)
Parâmetro |
Descrição |
|---|---|
|
Um número de ponto flutuante ou inteiro que representa o valor de entrada. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
robot.screen.print(erfc_result)
# erfc_result = 0.16