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 AIR. 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 Controlador de Drone VEX AIR. Também pode converter entre graus e radianos, avaliar expressões e trabalhar com valores especiais como infinito e NaN.
Nota: Exceto quando explicitamente indicado o contrário, todos os valores devolvidos são números de ponto flutuante formatados com exatamente cinco casas decimais. Os valores com mais de cinco casas decimais são arredondados, e os valores com menos de cinco casas decimais são complementados com zeros à esquerda, de modo a que sejam sempre apresentadas exactamente cinco casas decimais.
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.asin– Arco seno de um valor em radianos.math.acos– Arcocosseno de um valor em radianos.math.atan– Arco tangente de um valor em radianos.math.atan2– Arco tangente de y/x em radianos, considerando o quadrante.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.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)
controller.screen.print(abs_result)
# abs_result = 10
round#
round devolve um número arredondado para um número especificado de casas decimais, resultando num número inteiro.
Usage:
round(x, ndigits)
Parâmetro |
Descrição |
|---|---|
|
Um número inteiro ou de ponto flutuante. |
|
Opcional. Controla quantas casas decimais utilizar para arredondar (entre 0 e 5). O predefinido é 0. Quando este parâmetro é utilizado, arredondar para 1 |
# Round 5.7 to the nearest integer
round_int_result = round(5.7)
controller.screen.print(round_int_result)
# round_int_result = 6
# Round 3.14159 to 2 decimal places
round_result = round(3.14159, 2)
controller.screen.print(round_result)
# round_result = 3.14000
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)
controller.screen.print(min_result)
# min_result = 1
# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
controller.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)
controller.screen.print(max_result)
# max_result = 7
# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
controller.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])
controller.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)
controller.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)
controller.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow devolve um número elevado a uma potência e, opcionalmente, executa uma operação de módulo como um número inteiro.
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)
controller.screen.print(pow_result)
# pow_result = 8
# Calculate (5 ** 3) % 7
pow_mod_result = pow(5, 3, 7)
controller.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)
controller.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)
controller.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
controller.screen.print(apples_per_person)
# Output: 3.00000
# Convert a string into a float to use in calculations
user_input = "23.4"
user_number = float(user_input)
controller.screen.print(user_number * 3)
# Output: 70.20000
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
controller.screen.print(circle_area)
# circle_area = 78.53982
tau#
tau dá o valor de 2π.
Usage:
math.tau
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
controller.screen.print(circumference)
# circumference = 31.41593
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)
controller.screen.print(e_power)
# e_power = 7.38906
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):
controller.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):
controller.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 número de ponto flutuante ou inteiro que representa um ângulo em radianos. |
# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
controller.screen.print(sine_result)
# sine_result = 0.50000
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 número de ponto flutuante ou inteiro que representa um ângulo em radianos. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
controller.screen.print(cosine_result)
# cosine_result = 0.50000
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 número de ponto flutuante ou inteiro que representa um ângulo em radianos. |
# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
controller.screen.print(tangent_result)
# tangent_result = 1.00000
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 radians
arc_sine_result = math.asin(0.5)
controller.screen.print(arc_sine_result)
# arc_sine_result = 0.52360
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 radians
arc_cosine_result = math.acos(0.5)
controller.screen.print(arc_cosine_result)
# arc_cosine_result = 1.04720
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 radians
arc_tangent_result = math.atan(1)
controller.screen.print(arc_tangent_result)
# arc_tangent_result = 0.78540
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 valor do tipo float ou inteiro que representa a coordenada x. |
# Calculate the inverse tangent of (4, 3) in radians
atan2_result = math.atan2(3, 4)
controller.screen.print(atan2_result)
# atan2_result = 0.64350
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)
controller.screen.print(degrees_result)
# degrees_result = 180.00000
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)
controller.screen.print(radians_result)
# radians_result = 3.14159
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)
controller.screen.print(sinh_result)
# sinh_result = 1.7520
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)
controller.screen.print(cosh_result)
# cosh_result = 1.54308
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)
controller.screen.print(tanh_result)
# tanh_result = 0.76159
asinh#
asinh calcula o seno hiperbólico inverso 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)
controller.screen.print(asinh_result)
# asinh_result = 0.88137
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)
controller.screen.print(acosh_result)
# acosh_result = 1.31696
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)
controller.screen.print(atanh_result)
# atanh_result = 0.54931
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)
controller.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)
controller.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)
controller.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)
controller.screen.print(fabs_result)
# fabs_result = 3.70000
Exponents & Logarithms#
prisioneiro de guerra#
pow eleva x à potência de y (xy) e devolve um float.
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)
controller.screen.print(power_result)
# power_result = 8.00000
raiz quadrada#
A função sqrt calcula a raiz quadrada de um número e devolve um valor do tipo float.
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)
controller.screen.print(sqrt_result)
# sqrt_result = 4.00000
exp#
exp devolve e elevado à potência de x (ex) e como um 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)
controller.screen.print(exp_result)
# exp_result = 2.71828
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)
controller.screen.print(log_result)
# log_result = 2.00000
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)
controller.screen.print(log10_result)
# log10_result = 3.00000
log2#
log2 calcula o logaritmo na base 2 de um número e devolve um 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)
controller.screen.print(log2_result)
# log2_result = 3.00000
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)
controller.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)
controller.screen.print(expm1_result)
# expm1_result = 1.71828
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)
controller.screen.print(fractional_part)
controller.screen.next_row()
controller.screen.print(integer_part)
# fractional_part = 0.14159
# integer_part = 3.00000
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)
controller.screen.print(mantissa)
controller.screen.next_row()
controller.screen.print(exponent)
# mantissa = 0.50000
# 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)
controller.screen.print(fmod_result)
# fmod_result = 1.00000
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)
controller.screen.print(copysign_result)
# copysign_result = 10.00000
ldexp#
ldexp calcula x * (2 ** exp), que é equivalente a x * 2exp.
Usage:
math.ldexp(x, exp)
Parâmetro |
Descrição |
|---|---|
|
O valor base. |
|
O expoente. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
controller.screen.print(ldexp_result)
# ldexp_result = 48.00000
Comparison & Approximation#
é 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)
controller.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)
controller.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)
controller.screen.print(is_inf_true)
# is_inf_true = True
# Check if 42 is an infinite number (returns False)
is_inf_false = math.isinf(42)
controller.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)
controller.screen.print(is_nan_true)
# is_nan_true = True
# Check if 42 is NaN (returns False)
is_nan_false = math.isnan(42)
controller.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)
controller.screen.print(gamma_result)
# gamma_result = 24.00000
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)
controller.screen.print(lgamma_result)
# lgamma_result = 3.17805
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)
controller.screen.print(erf_result)
# erf_result = 0.84270
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)
controller.screen.print(erfc_result)
# erfc_result = 0.15730