math – Mathematical functions¶ (Français)

Number-theoretic and representation functions¶

math.ceil(x)¶

retourne le plafond de x, le plus petit entier supérieur ou égal à X. Si x n’est pas un nombre flottant, »dcd58ecb92″>, qui devrait renvoyer une valeurIntegral.

math.comb(n, k)¶

renvoie le nombre de façons de choisir k éléments parmi n éléments sans répétition et sans ordre.,

donne n! / (k! * (n - k)!) lors de la k <= n et evaluatesto zéro lors de la k > n.

aussi appelé coefficient binomial car il est équivalent au coefficient du k-th terme en expansion polynomiale de l’expression(1 + x) ** n.

déclencheTypeError si l’un des arguments n’est pas un entier.Déclenche ValueError si l’un des arguments est négatif.

math.copysign(x, y)¶math.fabs(x)¶

Return the absolute value of x.

math.factorial(x)¶

Return x factorial as an integer. Raises ValueError if x is not integral oris negative.

math.floor(x)¶math.fmod(x, y)¶

Return fmod(x, y), tel que défini par la plate-forme de C de la bibliothèque. Notez que l’expression thePython x % y peut ne pas renvoyer le même résultat. L’intention de la norme Cstandard est que fmod(x, y)soit exactement (mathématiquement; à l’infiniteprecision) égal à x - n*ypour un entier n tel que le résultat ait le même signe que x et une magnitude inférieure à abs(y)., Python x % yrenvoie un résultat avec le signe de y à la place, et peut ne pas être exactement computablefor arguments float. Par exemple, fmod(-1e-100, 1e100) est -1e-100, maisle résultat de Python -1e-100 % 1e100 est 1e100-1e-100, qui ne peut pas être représenté exactement comme un flottant, et arrondit à l’étonnant 1e100. Pour cette raison ,la fonctionfmod() est généralement préférée lorsque vous travaillez avec des flotteurs, tandis que Pythonx % y est préférée lorsque vous travaillez avec des entiers.,

math.frexp(x)¶math.fsum(itératif)¶

de Retour d’une précision à virgule flottante somme des valeurs dans la itératif. Évitez la perte de précision en suivant plusieurs sommes partielles intermédiaires:

>>> sum()0.9999999999999999>>> fsum()1.0

la précision de l’algorithme dépend des garanties arithmétiques IEEE-754 et du cas typique où le mode d’arrondi est Demi-Pair., Sur certains non-Windowsbuilds, la bibliothèque C sous-jacente utilise une addition de précision étendue et peut occasionnellement doubler une somme intermédiaire, ce qui la rend désactivée dans son dernier bit significatif.

pour une discussion plus approfondie et deux approches alternatives, voir le livre de recettes ASPNRECIPES pour une sommation précise en virgule flottante.

math.gcd(*entiers)¶

Retourner le plus grand diviseur commun de l’entier spécifié arguments.Si l’un des arguments est différent de zéro, alors la valeur renvoyée est le plus grand entier positif qui est un diviseur de tous les arguments., Si tous les arguments sont nuls, la valeur renvoyée est 0. gcd() sans arguments 0.

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)¶

Return True si les valeurs a et b sont proches les uns des autres etFalse le contraire.,

Le fait que deux valeurs soient considérées proches ou non est déterminé en fonction des tolérances absolues et relatives données.

rel_tol est la tolérance relative – c’est la différence maximale autorisée entre a et b, par rapport à la plus grande valeur absolue de A ou B. Par exemple, pour définir une tolérance de 5%, passezrel_tol=0.05. La valeur defaulttolerance est 1e-09, ce qui garantit que les deux valeurs sont identiques avec environ 9 chiffres décimaux. rel_tol doit être supérieur à zéro.

abs_tol est la tolérance absolue minimale – utile pour les comparaisons nearzero., abs_tol doit être au moins égal à zéro.

Si aucune erreur ne se produit, le résultat sera:abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

Les valeurs spéciales IEEE 754 deNaN,inf, et-inf seront contrôlées selon les règles de L’IEEE. Plus précisément, NaN n’est pas consideredclose à toute autre valeur, y compris NaN. infEt -inf ne sont considérés que comme proches d’eux-mêmes.

math.isfinite(x)¶

Return True if x is neither an infinity nor a NaN, andFalse otherwise. (Note that 0.0 is considered finite.)

math.isinf(x)¶

Return True if x is a positive or negative infinity, andFalse otherwise.,

math.isnan(x)¶

Return True si x est un NaN (pas un nombre), et False le contraire.

math.isqrt(n)¶

renvoie la racine carrée entière de l’entier non négatif N. c’est le plancher de la racine carrée exacte de n, ou de manière équivalente le plus grand entier tel que A2 ≤ N.

pour certaines applications, il peut, ou en d’autres termes le plafond dela racine carrée exacte de N., Pour n positif, cela peut être calculé en utilisant a = 1 + isqrt(n - 1).

math.lcm(*entiers)¶

Retourner le plus petit commun multiple de l’entier spécifié arguments.Si tous les arguments sont non nuls, alors la valeur renvoyée est le plus petit entier positif qui est un multiple de tous les arguments. Si l’un des arguments est nul, alors la valeur renvoyée est 0. lcm() sans arguments 1.

math.ldexp(x, i)¶

Return x * (2**i). C’est essentiellement l’inverse de la fonctionfrexp().

math.modf(x)¶

renvoie les parties fractionnaires et entières de X. Les deux résultats portent le signof x et sont flottants.

renvoie la valeur en virgule flottante suivante après x vers Y.

Si x est égal à y, renvoie Y.

exemples:

Voir aussimath.ulp().

math.perm(n, k=None)¶

renvoie le nombre de façons de choisir k éléments à partir de n itemssans répétition et avec ordre.

donne n! / (n - k)! lors de la k <= n et evaluatesto zéro lors de la k > n.

Si k n’est pas spécifié ou est None, alors k par défaut est nand la fonction renvoien!.

déclencheTypeError si l’un des arguments n’est pas un entier.Déclenche ValueError si l’un des arguments est négatif.,

math.prod(itératif, *, start=1)¶

Calculer le produit de tous les éléments de l’entrée itératif.La valeur de démarrage par défaut du produit est 1.

lorsque l’itérable est vide, renvoie la valeur de début. Cette fonction est spécialement conçue pour être utilisée avec des valeurs numériques et peut rejeter des types non numériques.

math.remainder(x, y)¶

renvoie le reste de x de style IEEE 754 par rapport à Y., Forfinite x et finie non nulle y, c’est la différence x - n*y,où n est l’entier le plus proche de la valeur exacte du quotient x /y. Si x / y est exactement à mi-chemin entre deux entiers consécutifs, l’entier le plus Pair est utilisé pour n. Le reste r = remainder(x,y) donc toujours satisfait abs(r) <= 0.5 * abs(y).,

des cas particuliers suivent IEEE 754: en particulier, remainder(x, math.inf) isx pour tout x fini, et remainder(x, 0) Etremainder(math.inf, x) raise ValueError pour tout x non-NaN.si le résultat de l’opération restante est zéro, ce zéro aura le même signe que X.

sur les plates-formes utilisant IEEE 754 binaire à virgule flottante, le résultat de cette opération est toujours exactement représentable: aucune erreur d’arrondi n’est introduite.

math.trunc(x)¶

de Retour de la balise Real valeur de x tronquée à unIntegral (généralement un entier). Délégués à x.__trunc__().

math.ulp(x)¶

de Retour de la valeur du bit le moins significatif de l’float x:

• Si x est un NaN (pas un nombre), de retour de x.

• Si x est négatif, retour ulp(-x).

• Si x est un infini positif, retournez X.,

• Si x est égal à zéro, renvoie le plus petit flotteur représentable positivedenormalisé (plus petit que le flotteur positivenormalisé minimum, sys.float_info.min).

• Si x est égal au plus grand flottant représentable positif,retournez la valeur du bit le moins significatif de x, de sorte que le firstfloat plus petit que x soitx - ulp(x).

• sinon (x est un nombre fini positif), retournez la valeur du bit le moins significatif de x, de sorte que le premier flotteur plus grand que xis x + ulp(x).,

ULP signifie « Unité dans la Dernière Place”.

Voir aussi math.nextafter() et sys.float_info.epsilon.

notez quefrexp() Etmodf() ont un modèle d’appel / retour différent de leurs équivalents C: ils prennent un seul argument et renvoient une paire de valeurs, plutôt que de renvoyer leur deuxième valeur de retour via un ‘outputparameter’ (il n’y a pas une telle chose en Python).,

pour les fonctionsceil(),floor() Etmodf(), notez que tous les nombres de points flottants de magnitude suffisamment grande sont des entiers exacts.Les flotteurs Python ne portent généralement pas plus de 53 bits de précision (la même que le type double plate-forme C), auquel cas tout flotteur X avec abs(x) >= 2**52n’a nécessairement pas de bits fractionnaires.