Mathématiques#
Introduction#
Le module Math inclut des fonctions Python intégrées ainsi que le module complet math , disponible automatiquement dans VEXcode AIR. Ces outils permettent d’effectuer toutes les opérations, des calculs arithmétiques de base aux opérations trigonométriques avancées, en passant par l’arrondi et les calculs logarithmiques.
Utilisez ces fonctions et constantes pour calculer les positions, les angles, les distances et autres valeurs numériques du contrôleur de drone VEX AIR. Vous pouvez également convertir des degrés en radians, évaluer des expressions et manipuler des valeurs spéciales comme l’infini et NaN.
Remarque : Sauf indication contraire, toutes les valeurs renvoyées sont des nombres à virgule flottante formatés avec exactement cinq décimales. Les valeurs comportant plus de cinq décimales sont arrondies, et celles en comportant moins de cinq sont complétées par des zéros afin d’afficher systématiquement cinq décimales.
Vous trouverez ci-dessous une liste des fonctions mathématiques, constantes et utilitaires disponibles :
Fonctions intégrées – Outils mathématiques courants inclus dans Python.
abs– Renvoie la valeur absolue d’un nombre.round– Arrondit un nombre à un nombre spécifié de décimales.min– Renvoie la plus petite des valeurs d’entrée.max– Renvoie la plus grande des valeurs d’entrée.sum– Additionne toutes les valeurs d’un itérable.divmod– Renvoie le quotient et le reste sous forme de tuple.pow– Élève un nombre à une puissance, éventuellement avec un module.int– Convertit une valeur en un entier.float– Convertit une valeur en un nombre à virgule flottante.
Constantes – Valeurs prédéfinies du module mathématique math.
math.pi– La constante π (pi).math.tau– La constante tau (2π).math.e– Nombre d’Euler, base du logarithme naturel.math.inf– Infini positif.math.nan– Pas un nombre (NaN).
Trigonométrie – Calcul des angles et des relations entre les côtés.
math.sin– Sinus d’un angle en radians.math.cos– Cosinus d’un angle en radians.math.tan– Tangente d’un angle en radians.math.asin– Arcsinus d’une valeur en radians.math.acos– Arccosinus d’une valeur en radians.math.atan– Arctangente d’une valeur en radians.math.atan2– Arctangente de y/x en radians, en considérant le quadrant.math.degrees– Convertit les radians en degrés.math.radians– Convertit les degrés en radians.
Hyperboliques – Fonctions trigonométriques avancées.
math.sinh– Sinus hyperbolique d’une valeur.math.cosh– Cosinus hyperbolique d’une valeur.math.tanh– Tangente hyperbolique d’une valeur.math.asinh– Sinus hyperbolique inverse.math.acosh– Cosinus hyperbolique inverse.math.atanh– Tangente hyperbolique inverse.
Arrondi et valeur absolue – Ajustez la précision ou la direction.
math.ceil– Arrondit à l’entier supérieur le plus proche.math.floor– Arrondit à l’entier inférieur le plus proche.math.trunc– Supprime la partie décimale.math.fabs– Renvoie la valeur absolue sous forme de nombre flottant.
Exposants et logarithmes – Calculs de puissance, de racine et de logarithme.
math.pow– Élève un nombre à une puissance.math.sqrt– Renvoie la racine carrée.math.exp– Calcule e à la puissance x.math.log– Logarithme naturel (base e).math.log10– Logarithme en base 10.math.log2– Logarithme en base 2.math.factorial– Factorielle d’un entier.math.expm1– Résultat plus précis poure^x - 1.
Opérations sur les nombres à virgule flottante – Examiner ou décomposer les valeurs flottantes.
math.modf– Renvoie les parties fractionnaire et entière d’un nombre flottant.math.frexp– Décompose un nombre en mantisse et exposant.math.fmod– Reste avec le signe du dividende.math.copysign– Renvoie une valeur avec le signe d’une autre.math.ldexp– Calculex * (2 ** exp).
Comparaison et approximation – Vérifiez les valeurs en tenant compte des tolérances ou des catégories.
math.isfinite– Vérifie si un nombre est fini.math.isinf– Vérifie si un nombre est infini.math.isnan– Vérifie si une valeur est NaN.
Erreur et Gamma – Fonctions mathématiques spéciales.
math.gamma– Fonction Gamma (factorielle généralisée).math.lgamma– Gamma logarithmique.math.erf– Fonction d’erreur.math.erfc– Fonction d’erreur complémentaire.
Fonctions intégrées#
Python propose plusieurs fonctions intégrées qui vous permettent d’effectuer des opérations mathématiques au sein de votre projet.
abs#
abs renvoie la valeur absolue d’un nombre, en supprimant tout signe négatif.
Usage:
abs(x)
Paramètre |
Description |
|---|---|
|
Un entier ou un nombre à virgule flottante. |
# Get the absolute value of -10
abs_result = abs(-10)
controller.screen.print(abs_result)
# abs_result = 10
round#
La fonction round renvoie un nombre arrondi à un nombre spécifié de décimales sous forme d’entier.
Usage:
round(x, ndigits)
Paramètre |
Description |
|---|---|
|
Un entier ou un nombre à virgule flottante. |
|
Optionnel. Contrôle le nombre de décimales à arrondir (entre 0 et 5). La valeur par défaut est 0. Lorsque ce paramètre est utilisé, l’arrondi |
# 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 renvoie la plus petite valeur parmi plusieurs arguments ou un itérable.
Usage:
min(arg1, arg2, …) or min(sequence)
Paramètre |
Description |
|---|---|
|
Les chiffres à comparer. |
|
Une liste, un tuple ou toute autre séquence contenant des nombres. |
# 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 renvoie la plus grande valeur parmi plusieurs arguments ou un itérable.
Usage:
max(arg1, arg2, …) or max(sequence)
Paramètre |
Description |
|---|---|
|
Les chiffres à comparer. |
|
Une liste, un tuple ou toute autre séquence contenant des nombres. |
# 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#
La fonction sum additionne toutes les valeurs d’un itérable, avec une valeur de départ optionnelle.
Usage:
sum(sequence, start)
Paramètre |
Description |
|---|---|
|
Une liste, un tuple ou toute autre séquence contenant des nombres. |
|
Facultatif. Valeur à ajouter à la somme. Par défaut : 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#
La fonction divmod renvoie un tuple contenant le quotient et le reste d’une opération de division.
Usage:
divmod(a, b)
Paramètre |
Description |
|---|---|
|
Le dividende. |
|
Le diviseur. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
controller.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow renvoie un nombre élevé à une puissance et effectue éventuellement une opération modulo en tant qu’entier.
Usage:
pow(x, y, mod)
Paramètre |
Description |
|---|---|
|
Le nombre de base. |
|
L’exposant. |
|
Facultatif. Une valeur de module. Si elle est fournie, renvoie |
# 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 convertit un nombre ou une chaîne de caractères en entier. Elle prend également en charge la conversion de base lors de la conversion à partir d’une chaîne de caractères.
Usage:
int(x, base)
Paramètre |
Description |
|---|---|
|
Un nombre, une chaîne de caractères ou tout autre objet à convertir. |
|
Facultatif. Base numérique à utiliser pour la conversion. Par défaut : 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 convertit un nombre ou une chaîne de caractères en un nombre à virgule flottante.
Usage:
float(x)
Paramètre |
Description |
|---|---|
|
Un nombre, une chaîne de caractères ou tout autre objet à convertir. |
# 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
Module de mathématiques#
Le module math de MicroPython fournit des méthodes supplémentaires pour effectuer des calculs mathématiques courants. Ces méthodes incluent les opérations trigonométriques, logarithmiques et autres opérations numériques.
Le module math est importé par défaut dans VEXcode.
Constants#
Les constantes sont des valeurs prédéfinies qui restent fixes pendant toute la durée d’un projet. Elles peuvent être utilisées dans les calculs sans nécessiter de définition ni d’affectation.
pi#
pi donne la constante mathématique π, le rapport entre la circonférence d’un cercle et son diamètre.
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 donne la valeur 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 donne la base du logarithme naturel.
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
inf#
inf donne l’infini positif sous forme de nombre flottant.
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 représente un nombre flottant spécial pour « Pas un nombre » (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#
péché#
La fonction sin calcule le sinus d’un angle en radians et renvoie un nombre flottant.
Usage:
math.sin(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier représentant un angle en radians. |
# 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#
La fonction cos calcule le cosinus d’un angle en radians et renvoie un nombre flottant.
Usage:
math.cos(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier représentant un angle en radians. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
controller.screen.print(cosine_result)
# cosine_result = 0.50000
tanné#
La fonction tan calcule la tangente d’un angle en radians et renvoie un nombre flottant.
Usage:
math.tan(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier représentant un angle en radians. |
# 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#
La fonction asin calcule l’arc sinus d’un nombre et renvoie un nombre flottant représentant l’angle en radians.
Usage:
math.asin(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier compris entre -1 et 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 calcule le cosinus inverse (arc cosinus) d’un nombre et renvoie un nombre flottant représentant l’angle en radians.
Usage:
>math.acos(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier compris entre -1 et 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 calcule l’arc tangente d’un nombre et renvoie un nombre flottant représentant l’angle en radians.
Usage:
math.atan(x)
Paramètre |
Description |
|---|---|
|
Un nombre à virgule flottante ou un entier. |
# 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 calcule la valeur principale de l’inverse tangente de y/x et renvoie un nombre flottant représentant l’angle en radians.
Usage:
math.atan2(y, x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou entier représentant la coordonnée y. |
|
Un nombre flottant ou entier représentant la coordonnée 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
diplômes#
degrees convertit un angle de radians en degrés.
Usage:
math.degrees(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier représentant un angle en radians. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
controller.screen.print(degrees_result)
# degrees_result = 180.00000
radians#
radians convertit un angle de degrés en radians.
Usage:
math.radians(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier représentant un angle en degrés. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
controller.screen.print(radians_result)
# radians_result = 3.14159
Hyperbolics#
sinh#
sinh calcule le sinus hyperbolique de x.
Usage:
math.sinh(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier représentant la valeur d’entrée. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
controller.screen.print(sinh_result)
# sinh_result = 1.7520
matraque#
cosh calcule le cosinus hyperbolique de x.
Usage:
math.cosh(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier représentant la valeur d’entrée. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
controller.screen.print(cosh_result)
# cosh_result = 1.54308
tanh#
tanh calcule la tangente hyperbolique de x.
Usage:
math.tanh(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier représentant la valeur d’entrée. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
controller.screen.print(tanh_result)
# tanh_result = 0.76159
asinh#
asinh calcule le sinus hyperbolique inverse de x.
Usage:
math.asinh(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier représentant la valeur d’entrée. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
controller.screen.print(asinh_result)
# asinh_result = 0.88137
acosh#
acosh calcule le cosinus hyperbolique inverse de x.
Usage:
math.acosh(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier supérieur ou égal à 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
controller.screen.print(acosh_result)
# acosh_result = 1.31696
atanh#
atanh calcule la tangente hyperbolique inverse de x.
Usage:
math.atanh(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant compris entre -1 et 1 (exclu). |
# 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#
plafond#
ceil arrondit un nombre à l’entier supérieur le plus proche.
Usage:
math.ceil(x)
Paramètre |
Description |
|---|---|
|
Un nombre décimal ou entier à arrondir à l’entier supérieur. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
controller.screen.print(ceil_result)
# ceil_result = 4
sol#
floor arrondit un nombre à l’entier inférieur le plus proche.
Usage:
math.floor(x)
Paramètre |
Description |
|---|---|
|
Un nombre décimal ou entier à arrondir à l’inférieur. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
controller.screen.print(floor_result)
# floor_result = 3
troncature#
trunc supprime la partie décimale d’un nombre sans arrondir.
Usage:
math.trunc(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant à tronquer. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
controller.screen.print(trunc_result)
# trunc_result = 3
fabs#
fabs renvoie la valeur absolue d’un nombre sous forme de nombre flottant.
Usage:
math.fabs(x)
Paramètre |
Description |
|---|---|
|
Un nombre à virgule flottante ou un entier. |
# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
controller.screen.print(fabs_result)
# fabs_result = 3.70000
Exponents & Logarithms#
pouvoir#
pow élève x à la puissance y (xy) et renvoie un flottant.
Usage:
math.pow(x, y)
Paramètre |
Description |
|---|---|
|
Une base flottante ou entière. |
|
Un exposant flottant ou entier. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
controller.screen.print(power_result)
# power_result = 8.00000
racine carrée#
La fonction sqrt calcule la racine carrée d’un nombre et renvoie un nombre flottant.
Usage:
math.sqrt(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier non négatif. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
controller.screen.print(sqrt_result)
# sqrt_result = 4.00000
exp#
exp renvoie e élevé à la puissance de x (ex) et sous forme de nombre flottant.
Usage:
math.exp(x)
Paramètre |
Description |
|---|---|
|
Un nombre à virgule flottante ou un entier. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
controller.screen.print(exp_result)
# exp_result = 2.71828
enregistrer#
La fonction log calcule le logarithme naturel d’un nombre et renvoie un nombre flottant.
Usage:
math.log(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier positif. |
# 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 calcule le logarithme décimal d’un nombre et renvoie un nombre flottant.
Usage:
math.log10(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier positif. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
controller.screen.print(log10_result)
# log10_result = 3.00000
log2#
log2 calcule le logarithme en base 2 d’un nombre et renvoie un nombre flottant, même lorsque x est une puissance de 2.
Usage:
math.log2(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier positif. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
controller.screen.print(log2_result)
# log2_result = 3.00000
factorielle#
factorial renvoie la factorielle d’un entier x, qui est le produit de tous les entiers positifs jusqu’à x.
Usage:
math.factorial(x)
Paramètre |
Description |
|---|---|
|
Un entier non négatif. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
controller.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 calcule ex - 1, ce qui est plus précis pour les petits x.
Usage:
math.expm1(x)
Paramètre |
Description |
|---|---|
|
La valeur de l’exposant. |
# 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 décompose un nombre en ses parties fractionnaire et entière et renvoie un tuple (fractional part, integer part), les deux sous forme de nombres flottants.
Usage:
math.modf(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou entier à décomposer. |
# 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 décompose un nombre en sa mantisse et son exposant et renvoie un tuple (mantissa, exponent), où la mantisse est un nombre flottant et l’exposant est un entier.
Usage:
math.frexp(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou entier à décomposer. |
# 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 renvoie le reste de la division tout en conservant le signe du dividende (x).
Usage:
math.fmod(x, y)
Paramètre |
Description |
|---|---|
|
Le dividende. |
|
Le diviseur. |
# 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
copyright#
copysign renvoie x avec le signe de y.
Usage:
math.copysign(x, y)
Paramètre |
Description |
|---|---|
|
La valeur à modifier. |
|
La valeur dont le signe sera copié. |
# 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 calcule x * (2 ** exp), ce qui est équivalent à x * 2exp.
Usage:
math.ldexp(x, exp)
Paramètre |
Description |
|---|---|
|
La valeur de base. |
|
L’exposant. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
controller.screen.print(ldexp_result)
# ldexp_result = 48.00000
Comparison & Approximation#
est infini#
isfinite vérifie si un nombre est fini. Cette méthode renvoie une valeur booléenne :
True- Le nombre est fini.False- Le nombre est infini.
Usage:
math.isfinite(x)
Paramètre |
Description |
|---|---|
|
Un nombre décimal ou entier à vérifier. |
# 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
isinf#
La méthode isinf vérifie si un nombre est infini. Elle renvoie une valeur booléenne.
True- Le nombre est infini.False- Le nombre est fini.
Usage:
math.isinf(x)
Paramètre |
Description |
|---|---|
|
Un nombre décimal ou entier à vérifier. |
# 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#
isnan vérifie si un nombre est NaN (Not a Number). Cette méthode renvoie une valeur booléenne :
True- Le nombre est NaN.False- Le nombre est un nombre valide.
Usage:
math.isnan(x)
Paramètre |
Description |
|---|---|
|
Un nombre décimal ou entier à vérifier. |
# 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#
gamma#
gamma calcule la fonction gamma de x, qui généralise la fonction factorielle pour les nombres réels et complexes. Pour un entier n, gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier positif. |
# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
controller.screen.print(gamma_result)
# gamma_result = 24.00000
lgamma#
lgamma calcule le logarithme naturel de la fonction gamma.
Usage:
math.lgamma(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier positif. |
# Calculate the natural logarithm of the
# gamma function of 5
lgamma_result = math.lgamma(5)
controller.screen.print(lgamma_result)
# lgamma_result = 3.17805
erf#
erf calcule la fonction d’erreur de x.
Usage:
math.erf(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier représentant la valeur d’entrée. |
# Calculate the error function of 1
erf_result = math.erf(1)
controller.screen.print(erf_result)
# erf_result = 0.84270
erfc#
erfc calcule la fonction d’erreur complémentaire de x, qui est définie comme 1 - erf(x).
Usage:
math.erfc(x)
Paramètre |
Description |
|---|---|
|
Un nombre flottant ou un entier représentant la valeur d’entrée. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
controller.screen.print(erfc_result)
# erfc_result = 0.15730