Mathématiques#

Introduction#

Le module Math inclut des fonctions Python intégrées ainsi que le module complet math , disponible automatiquement dans VEXcode GO. 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 de votre robot. Vous pouvez également convertir entre degrés et radians, évaluer des expressions et manipuler des valeurs spéciales comme l’infini et NaN.

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.

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.atan – Arctangente d’une valeur en radians.

  • math.atan2 – Arctangente de y/x en radians, en considérant le quadrant.

  • math.asin – Arcsinus d’une valeur en radians.

  • math.acos – Arccosinus d’une valeur en radians.

  • math.degrees – Convertit les radians en degrés.

  • math.radians – Convertit les degrés en radians.

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 – Calculer le logarithme de x.

  • math.log10 – Calcule le logarithme en base 10 de x.

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 – Calcule x * (2 ** exp).

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

x

Un entier ou un nombre à virgule flottante.

 
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 arrondit un nombre à un nombre spécifié de décimales.

Usage:
round(x, ndigits)

Paramètre

Description

x

Un entier ou un nombre à virgule flottante.

ndigits

Facultatif. Nombre de décimales à arrondir. La valeur par défaut est 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 renvoie la plus petite valeur parmi plusieurs arguments ou un itérable.

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

Paramètre

Description

arg1, arg2, …

Les chiffres à comparer.

sequence

Une liste, un tuple ou toute autre séquence contenant des nombres.

 
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 renvoie la plus grande valeur parmi plusieurs arguments ou un itérable.

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

Paramètre

Description

arg1, arg2, …

Les chiffres à comparer.

sequence

Une liste, un tuple ou toute autre séquence contenant des nombres.

 
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#

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

sequence

Une liste, un tuple ou toute autre séquence contenant des nombres.

start

Facultatif. Valeur à ajouter à la somme. Par défaut : 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#

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

a

Le dividende.

b

Le diviseur.

 
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 élève un nombre à une puissance et effectue éventuellement une opération modulo.

Usage:
pow(x, y, mod)

Paramètre

Description

x

Le nombre de base.

y

L’exposant.

mod

Facultatif. Une valeur de module. Si elle est fournie, renvoie (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#

La fonction 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

x

Un nombre, une chaîne de caractères ou tout autre objet à convertir.

base

Facultatif. Base numérique à utiliser pour la conversion. Par défaut : 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 convertit un nombre ou une chaîne de caractères en un nombre à virgule flottante.

Usage:
float(x)

Paramètre

Description

x

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

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

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 donne la valeur 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 donne la base du logarithme naturel.

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#

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

x

Un nombre flottant ou un entier représentant un angle en radians.

 
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#

La fonction cos calcule le cosinus d’un angle en radians et renvoie un nombre flottant.

Usage:
math.cos(x)

Paramètre

Description

x

Un nombre flottant ou un entier représentant un angle en radians.

 
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)

tanné#

La fonction tan calcule la tangente d’un angle en radians et renvoie un entier.

Usage:
math.tan(x)

Paramètre

Description

x

Un nombre flottant ou un entier représentant un angle en radians.

 
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#

La fonction asin calcule l’arc sinus d’un nombre et renvoie un entier représentant l’angle en radians.

Usage:
math.asin(x)

Paramètre

Description

x

Un nombre flottant ou un entier compris entre -1 et 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 calcule l’arc cosinus d’un nombre et renvoie un entier représentant l’angle en radians.

Usage:
math.acos(x)

Paramètre

Description

x

Un nombre flottant ou un entier compris entre -1 et 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 calcule l’arc tangente d’un nombre et renvoie un entier représentant l’angle en radians.

Usage:
math.atan(x)

Paramètre

Description

x

Un nombre à virgule flottante ou un entier.

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

y

Un nombre flottant ou entier représentant la coordonnée y.

x

Un nombre flottant ou entier représentant la coordonnée 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)

diplômes#

La fonction degrees convertit un angle de radians en degrés et renvoie un entier.

Usage:
math.degrees(x)

Paramètre

Description

x

Un nombre flottant ou un entier représentant un angle en radians.

 
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)

radians#

radians convertit un angle de degrés en radians.

Usage:
math.radians(x)

Paramètre

Description

x

Un nombre flottant ou un entier représentant un angle en degrés.

 
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#

plafond#

ceil arrondit un nombre à l’entier supérieur le plus proche.

Usage:
math.ceil(x)

Paramètre

Description

x

Un nombre décimal ou entier à arrondir à l’entier supérieur.

 
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)

sol#

floor arrondit un nombre à l’entier inférieur le plus proche.

Usage:
math.floor(x)

Paramètre

Description

x

Un nombre décimal ou entier à arrondir à l’inférieur.

 
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)

troncature#

trunc supprime la partie décimale d’un nombre sans arrondir.

Usage:
math.trunc(x)

Paramètre

Description

x

Un nombre flottant à tronquer.

 
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)

fabs#

fabs renvoie la valeur absolue d’un nombre sous forme de nombre flottant.

Usage:
math.fabs(x)

Paramètre

Description

x

Un nombre à virgule flottante ou un entier.

 
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#

enregistrer#

La fonction log calcule le logarithme d’un nombre et renvoie un nombre flottant.

Usage:
math.log(x, base)

Paramètre

Description

x

Un nombre flottant ou un entier positif.

base

Facultatif. Base du logarithme à utiliser. Par défaut, il s’agit du logarithme népérien.

 
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 calcule le logarithme décimal d’un nombre et renvoie un nombre flottant.

Usage:
math.log10(x)

Paramètre

Description

x

Un nombre flottant ou un entier positif.

 
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)

pouvoir#

La fonction pow élève x à la puissance y et renvoie un nombre flottant, même si les deux entrées sont des entiers.

Usage:
math.pow(x, y)

Paramètre

Description

x

Une base flottante ou entière.

y

Un exposant flottant ou entier.

 
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)

racine carrée#

La fonction sqrt calcule la racine carrée d’un nombre et renvoie un nombre flottant, même pour les carrés parfaits.

Usage:
math.sqrt(x)

Paramètre

Description

x

Un nombre flottant ou un entier non négatif.

 
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#

La fonction exp calcule l’exponentielle d’un nombre et renvoie un nombre flottant.

Usage:
math.exp(x)

Paramètre

Description

x

Un nombre à virgule flottante ou un entier.

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

x

Un nombre flottant ou entier à décomposer.

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

x

Un nombre flottant ou entier à décomposer.

 
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 renvoie le reste de la division tout en conservant le signe du dividende (x).

Usage:
math.fmod(x, y)

Paramètre

Description

x

Le dividende.

y

Le diviseur.

 
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)

copyright#

copysign renvoie x avec le signe de y.

Usage:
math.copysign(x, y)

Paramètre

Description

x

La valeur à modifier.

y

La valeur dont le signe sera copié.

 
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 calcule x * (2 ** exp), ce qui est équivalent à x * 2exp.

Usage:
math.ldexp(x, exp)

Paramètre

Description

x

La valeur de base.

exp

L’exposant.

 
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)
Sur cette page