4.3.1.1. Création¶

• Constructeur (Fraction)

  >>> repr(Fraction(5, 6))
  Fraction(5, 6)
  >>> repr(Fraction("x", 8))
  Fraction("x", 8)
  >>> repr(Fraction(3.14))
  Fraction(314, 100)
  >>> repr(Fraction(Fraction(1,3)))
  Fraction(1, 3)
  

• L’option code permet de préciser sur la décomposition a pour objectif une simplification "s" ou une mise au même dénominateur "r".

  >>> repr(Fraction("3*4", "3*7", "r").traitement())
  Fraction(12, 21)
  >>> repr(Fraction("3*4", "3*7", "s").traitement())
  Fraction(4, 7)
  

4.3.1.2. Opérations mathématiques¶

• Somme (Fraction.__add__() et Fraction.__radd__()).

  >>> Fraction(2,20) + Fraction(2,10)
  Fraction(2, 20)+Fraction("2*2", "10*2", "r")
  >>> repr(Fraction(5,10) + Fraction(2,10))
  Fraction(7, 10)
  >>> Fraction(5,7) + Fraction(2,10)
  Fraction("5*10", "7*10", "r")+Fraction("2*7", "10*7", "r")
  

• Différence (Fraction.__sub__() et Fraction.__rsub__())

  >>> Fraction(2,20) - Fraction(2,10)
  Fraction(2, 20)-Fraction("2*2", "10*2", "r")
  >>> repr(Fraction(5,10) - Fraction(2,10))
  Fraction(3, 10)
  >>> Fraction(5,7) - Fraction(2,10)
  Fraction("5*10", "7*10", "r")-Fraction("2*7", "10*7", "r")
  

• Produit (Fraction.__mul__())

  >>> repr(Fraction(2,5) * Fraction(2,10))
  Fraction("2*2", "5*2*5", "s")
  >>> repr(Fraction(2,5) * 4)
  Fraction(8, 5)
  

• Quotient (Fraction.__div__() et Fraction.__rtruediv__())

  >>> Fraction(2,5) / Fraction(10,2)
  Fraction(2, 5)*Fraction(2, 10)
  >>> Fraction(2,5) / 4
  Fraction(2, 5)*Fraction(1, 4)
  

• Puissance (Fraction.__pow__())

  >>> repr(Fraction(2,3)**4)
  Fraction(16, 81)
  

• Opposé (Fraction.__neg__())

  >>> repr(-Fraction(8,27))
  Fraction(-8, 27)
  

• Opérateur unaire + (Fraction.__pos__())

  >>> repr(+Fraction(8,27))
  Fraction(8, 27)
  

• Inverse (Fraction.__invert__())

  >>> repr(~Fraction(8,27))
  Fraction(27, 8)
  

• Valeur absolue (Fraction.__abs__())

  >>> repr(abs(Fraction(-5, 6)))
  Fraction(5, 6)
  >>> repr(abs(-Fraction(5, 6)))
  Fraction(5, 6)
  

• Troncature (Fraction.__trunc__())

  >>> import math
  >>> math.trunc(Fraction(7, 6))
  1
  

• Comparaison (Fraction.__eq__(), Fraction.__ge__(), Fraction.__gt__(), Fraction.__le__(), Fraction.__lt__(), Fraction.__ne__())

  >>> Fraction(5, 6) < 1
  True
  >>> Fraction(6, 6) == 1
  True
  >>> Fraction(3, 4) >= Fraction(6, 7)
  False
  

4.3.1.3. Opérations spécifiques aux fractions¶

• Changer le dénominateur (Fraction.choix_denominateur()). L’argument denominateur doit être un diviseur du dénominateur de la fraction, sans quoi le résultat sera aberrant.

  >>> repr(Fraction(5, 6).choix_denominateur(12))
  Fraction("5*2", "6*2", "r")
  >>> repr(Fraction(5, 6).choix_denominateur(4)) # Résultat aberrant.
  Fraction("5*0", "6*0", "r")
  

• Réduction du numérateur et du dénominateur (Fraction.reduit())

  >>> repr(Fraction(2*4,5*4).reduit())
  Fraction(8, 20)
  >>> repr(Fraction('2*4', '5*4').reduit())
  Fraction(8, 20)
  

• Simplification (Fraction.simplifie())

  >>> repr(Fraction(8, 20).simplifie())
  Fraction(2, 5)
  >>> repr(Fraction('2*4','5*4').simplifie())
  Fraction(2, 5)
  

• Décomposition (Fraction.decompose())

  >>> repr(Fraction(8,20).decompose())
  Fraction("2*4", "5*4", "s")
  

• Mise au même dénominateur, ou simplification (Fraction.traitement())

  >>> repr(Fraction("3*4", "3*7", "r").traitement())
  Fraction(12, 21)
  >>> repr(Fraction("3*4", "3*7", "s").traitement())
  Fraction(4, 7)
  >>> repr(Fraction(12, 21).traitement())
  Fraction(12, 21)
  >>> repr(Fraction(12, 21).traitement(True))
  Fraction("4*3", "7*3", "s")
  

4.3.1.4. Conversions¶

• Conversion en flottant (Fraction.__float__())

  >>> float(Fraction(5, 6))
  0.8333333333333334
  

• Conversion en entier (Fraction.__int__()). Cette méthode ne fonctionne que si la fraction est égale à un nombre entier. Sinon, elle lève une exception.

  >>> int(Fraction(15, 5))
  3
  >>> int(Fraction(15, 6))
  Traceback (most recent call last):
    ...
  AssertionError: La fraction n'est pas un nombre entier !
  

4.3.1.5. LaTeX¶

• Conversion d’une fraction en LaTeX (Fraction.__str__()).

  >>> str(Fraction(8, 3))
  \dfrac{8}{3}
  >>> str(Fraction(8, 1))
  8
  >>> str(Fraction('-5*2', '3*2', 'r'))
  \dfrac{-5_{\times 2}}{3_{\times 2}}
  

4.3.2.1. Création¶

• Constructeur (Polynome)

  >>> repr(Polynome("x^2-3x+1"))
  Polynome({2: Fraction(1, 1), 1: -3, 0: 1}, var="x")
  >>> repr(Polynome({2: 4, 1:8, 0:1, 3:0}))
  Polynome({2: Fraction(4, 1), 1: Fraction(8, 1), 0: Fraction(1, 1)}, var="x")
  

• Si l’argument est une liste, les coefficients sont donnés dans l’ordre des degrés des monômes (plus bas degré en premier), ce qui est l’inverse du sens de lecture habituel (plus haut degré en premier).

  >>> str(Polynome([1, 2, 3, 4]))
  4x^3+3x^2+2x+1
  

• L’argument var permet de changer le nom de la variable

  >>> str(Polynome([2, 3], var="z"))
  3z+2
  >>> str(Polynome([2, 3]))
  3x+2
  

4.3.2.2. Paramètres¶

• Taille (nombre de monômes, éventuellement nuls) (Polynome.__len__()).

  >>> len(Polynome([2, -3]))
  2
  >>> len(Polynome([2, 0, -3]))
  3
  

• Degré (Polynome.degre()).

  >>> Polynome([2, -3]).degre()
  1
  

• Accès à chacun des coefficients, en fonction du degré (Polynome.__getitem__()).

  >>> str(Polynome([2, -3]))
  -3x+2
  >>> Polynome([2, -3])[0]
  2
  >>> Polynome([2, -3])[1]
  -3
  

4.3.2.3. Opérations¶

• Somme (Polynome.__add__() et Polynome.__radd__()).

  >>> repr(Polynome([2, -3]) + Polynome([1, 2, 3]))
  Polynome({0: 3, 1: -1, 2: 3}, var="x")
  >>> repr(Polynome([2, -3]) + 1)
  Polynome({0: 3, 1: -3}, var="x")
  

• Produit (Polynome.__mul__()).

  >>> repr(Polynome([2, -3]) * Polynome([1, 2, 3]))
  Polynome({0: 2, 1: Fraction(1, 1), 3: Fraction(-9, 1)}, var="x")
  

• Puissance (Polynome.__pow__()).

  >>> repr(Polynome([2, -3])**2)
  Polynome({0: 4, 1: Fraction(-12, 1), 2: Fraction(9, 1)}, var="x")
  

• Différence (Polynome.__sub__() et Polynome.__rsub__()).

  >>> repr(Polynome([2, -3]) - Polynome([7, 3]))
  Polynome({0: -5, 1: -6}, var="x")
  

• Opposé (Polynome.__neg__()).

  >>> repr(-Polynome([2, -3]))
  Polynome({0: -2, 1: Fraction(3, 1)}, var="x")
  

• Division euclidienne (renvoit un tuple (dividende, reste)) (Polynome.__div__()).

  >>> repr(Polynome([2, -3]) / 2)
  Polynome({0: 1, 1: Fraction(-3, 2)}, var="x")
  >>> Polynome([1, 2, 3]) / Polynome([-2, 1])
  (Polynome({0: 8, 1: Fraction(3, 1)}, var="x"), Polynome({0: Fraction(17, 1)}, var="x"))
  >>> (Polynome([1, 2, 3]) * Polynome([3, -1])) / Polynome([3, -1])
  (Polynome({0: 1, 2: 3, 1: Fraction(2, 1)}, var="x"), Polynome({0: 0}, var="x"))
  

• Comparaison (Polynome.__eq__() et Polynome.__ne__()).

  >>> Polynome([2, -3]) == Polynome("-3x+2")
  True
  >>> Polynome([2, -3]) != Polynome("-3x+2")
  False
  

4.3.2.4. Opérations spécifiques¶

• Simplification (Polynome.simplifie()).

  >>> repr(Polynome([2, Fraction(12, 4)]).simplifie())
  Polynome({1: Fraction(3, 1), 0: Fraction(2, 1)}, var="x")
  

• Calcul d’image (Polynome.__call__()).

  >>> Polynome([2, -3])(1)
  -1
  >>> Polynome([2, -3])(float("inf"))
  -inf
  >>> Polynome([2, -3])("z")
  -3z+2
  >>> # Attention : Cette fonction n'ajoute pas les parenthèses nécessaires.
  >>> Polynome([2, -3])("z+1")
  -3z+1+2
  

• Recherche de racines évidentes (Polynome.racine_evidente()).

  >>> # Remarquons que la racine `-6/5` n'a pas été trouvée.
  >>> (Polynome([1, 1]) * Polynome([6, 5]) * Polynome([0, -2])).racine_evidente()
  [-1, 0]
  

• Factorise (Polynome.factorise()).

  Note

  Je ne suis pas l’auteur de cette fonction ; je ne sais pas comment elle est utilisée. Vu les exemples ci-dessous, son utilité doit être assez restreinte :

  • Apparemment, si un polynôme de degré n a moins de n racines (ou qu’une des racines n’est pas évidente, c’est à dire n’est pas un entier plus petit que 2 en valeur absolue), alors elle lève une exception.
  • Quand elle fonctionne, elle renvoit la liste des facteurs, mais elle renvoit plusieurs facteurs Polynome({0: 1}), c’est-à-dire égaux à la constante 1, ce qui est inutile.

  >>> Polynome([-2, -1, 1]).factorise()
  [Polynome({0: 1}, var="x"), Polynome({1: Fraction(1, 1), 0: Fraction(1, 1)}, var="x"), Polynome({1: Fraction(1, 1), 0: Fraction(-2, 1)}, var="x"), Polynome({0: 1}, var="x")]
  >>> # Polynôme de degré 3 avec une seule racine (pas évidente)
  >>> Polynome([-6, -7, -8, 15]).factorise()
  [Polynome({0: 15}, var="x"), Polynome({0: Fraction(-2, 5), 3: Fraction(1, 1), 2: Fraction(-8, 15), 1: Fraction(-7, 15)}, var="x")]
  

• Dérivation (Polynome.derive()).

  >>> repr(Polynome([1, 2, 3, 4]).derive())
  Polynome({0: 2, 1: 6, 2: 12}, var="x")
  

• Calcul de primitive (Polynome.primitive()).

  >>> repr(Polynome([2, -3]).primitive())
  Polynome({1: 2, 2: Fraction(-3, 2)}, var="x")
  

4.3.2.5. Conversion en LaTeX¶

• Conversion en LaTeX, avec les options par défaut (Polynome.__str__()).

  >>> str(Polynome([2, -3]))
  -3x+2
  >>> str(Polynome([2, 0, 0, -3]))
  -3x^3+2
  

• Conversion en LaTeX, avec plus d’options (Polynome.TeX()).

  >>> Polynome([2, -3]).TeX()
  -3x+2
  >>> Polynome([2, -3]).TeX(var="z")
  -3z+2
  >>> Polynome([2, -3]).TeX(parenthese=True)
  \left(-3x+2\right)
  

4.3.3.1. Constructeur¶

• Constructeur (Polynome.__init__()).

  >>> repr(Polynome([[-3, 2], [2, 1], [1, 0]]))
  Polynome([[-3, 2], [2, 1], [1, 0]], "x", 0)
  >>> repr(Polynome("2x^4-3+x^3"))
  Polynome([[2, 4], [-3, 0], [1, 3]], "x", 0)
  

• Les monômes peuvent se repéter.

  >>> repr(Polynome([[-3, 2], [2, 2], [1, 2]]))
  Polynome([[-3, 2], [2, 2], [1, 2]], "x", 0)
  

• La variable du polynôme peut être changée avec l’argument var.

  >>> str(Polynome([[-3, 2], [2, 1], [1, 0]]))
  -3\,x^{2}+2\,x+1
  >>> str(Polynome([[-3, 2], [2, 1], [1, 0]], var="z"))
  -3\,z^{2}+2\,z+1
  

• L’argument details décrit le niveau de détails voulus dans les développements et réductions.

  >>> repr(Polynome([[-3, 2], [2, 2], [1, 0]], details=0).nreduction())
  Polynome([[-1, 2], [1, 0]], "x", 0)
  >>> repr(Polynome([[-3, 2], [2, 2], [1, 0]], details=3).nreduction())
  Polynome([['-3+2', 2], [1, 0]], "x", 3)
  >>> repr(Polynome([[2, 1], [1, 0]], details=0) + Polynome([[2, 1], [1, 0]], details=0))
  Polynome([[4, 1], [2, 0]], "x", 0)
  >>> repr(Polynome([[2, 1], [1, 0]], details=3) + Polynome([[2, 1], [1, 0]], details=3))
  Polynome([[2, 1], [2, 1], [1, 0], [1, 0]], "x", 3)
  

• Constructeur à partir d’une liste de points, en utilisant l’interpolation de Lagrange (Lagrange()). Ce polynôme est davantage destiné à être tracé qu’à être utilisé pour des calculs.

  >>> Lagrange(((2,0), (4,2)))
  0+Fraction(2, 2)*Polynome("x-2", details = 0)
  >>> # Tracé d'un polynôme avec psplot
  >>> from pyromaths.outils.Priorites3 import plotify, priorites
  >>> plotify(priorites(Lagrange(((2,0), (4,2))))[-1])
  1*x^1-2
  

• Choix de points pour un polynôme de Lagrange (choix_points()). Renvoie un tuple contenant nb coordonnées sous forme de tuple telles que les abscisses et ordonnées sont distinctes, comprises entre min et max, une abscisse n’est jamais égale à une ordonnée et la coordonnée (b, a) n’est pas listée si la coordonnée (a, b) existe.

  >>> import random
  >>> random.seed(0)
  None
  >>> choix_points(-4, 4, nb=5)
  ((-3, -2), (-2, 1), (-1, 0), (0, -3), (1, -1))
  

4.3.3.2. Caractéristiques¶

• Accès aux coefficients (Polynome.__getitem__(), Polynome.__delitem__()).

  >>> Polynome([[-3, 2], [2, 1], [1, 0]])[0]
  [-3, 2]
  >>> Polynome([[-3, 2], [2, 1], [1, 0]])[1]
  [2, 1]
  

• Nombre de monômes (Polynome.__len__()).

  >>> len(Polynome([[-3, 1], [2, 1], [1, 0]]))
  3
  

• Degré (Polynome.degre()).

  >>> Polynome([[-3, 2], [2, 1], [1, 0]]).degre()
  2
  

4.3.3.3. Opérations¶

• Somme (Polynome.__add__(), Polynome.__radd__(), Polynome.__iadd__()).

  >>> repr(Polynome([[-3, 2], [2, 1], [1, 0]]) + Polynome([[2, 2], [-1, 0]]))
  Polynome([[-1, 2], [2, 1]], "x", 0)
  

• Comparaison (Polynome.__eq__(), Polynome.__ne__()). Les polynômes sont ordonnés avant comparaison, mais pas réduits.

  >>> Polynome([[-3, 2], [2, 1], [1, 0]]) == Polynome([[-3, 2], [1, 0], [2, 1]])
  True
  >>> Polynome([[1, 1], [1, 1]]) == Polynome([[2, 1]])
  False
  

• Différence (Polynome.__sub__(), Polynome.__rsub__()).

  >>> repr(Polynome([[-3, 2], [2, 1], [1, 0]]) - Polynome([[2, 1]]))
  Polynome([[-3, 2], [1, 0]], "x", 0)
  

• Opposé (Polynome.__neg__()).

  >>> repr(-Polynome([[-3, 2], [2, 1], [1, 0]]))
  Polynome([[3, 2], [-2, 1], [-1, 0]], "x", 0)
  

• Positif (Polynome.__pos__()).

  >>> repr(+Polynome([[-3, 2], [2, 1], [1, 0]]))
  Polynome([[-3, 2], [2, 1], [1, 0]], "x", 0)
  

• Produit (Polynome.__mul__(), Polynome.__rmul__()). Le résultat dépend de la valeur de l’attribut details (définit dans le constructeur). Le résultat n’est pas réduit.

  >>> Polynome([[2, 1], [1, 0]]) * Polynome([[1, 1], [1, 0]])
  Polynome([[2, 2]], "x", 0)+Polynome([[2, 1]], "x", 0)+Polynome([[1, 1]], "x", 0)+Polynome([[1, 0]], "x", 0)
  >>> Polynome([[2, 1], [1, 0]], details=0) * Polynome([[1, 1], [1, 0]])
  Polynome([[2, 2]], "x", 0)+Polynome([[2, 1]], "x", 0)+Polynome([[1, 1]], "x", 0)+Polynome([[1, 0]], "x", 0)
  >>> Polynome([[2, 1], [1, 0]], details=1) * Polynome([[1, 1], [1, 0]])
  Polynome([[2, 1]], "x", 1)*Polynome([[1, 1]], "x", 1)+Polynome([[2, 1]], "x", 1)*Polynome([[1, 0]], "x", 1)+Polynome([[1, 0]], "x", 1)*Polynome([[1, 1]], "x", 1)+Polynome([[1, 0]], "x", 1)*Polynome([[1, 0]], "x", 1)
  

• Modulo (Polynome.__mod__()).

  >>> Polynome([[-3, 2], [2, 1], [1, 0]]) % Polynome([[1, 1]])
  1
  

• Dividende (Polynome.__floordiv__()).

  >>> repr(Polynome([[-3, 2], [2, 1], [1, 0]]) // Polynome([[1, 1]]))
  Polynome([[-3, 1], [2, 0]], "x", 0)
  

• Puissance (Polynome.__pow__()).

  >>> Polynome([[2, 1], [1, 0]])**2
  Polynome([[2, 1]], "x", 0)**2+2*Polynome([[2, 1]], "x", 0)*Polynome([[1, 0]], "x", 0)+Polynome([[1, 0]], "x", 0)**2
  

4.3.3.4. Opérations spécifiques¶

• Calcul d’images (Polynome.__call__()). Cette méthode ne calcule rien, mais renvoie le calcul à effectuer.

  >>> Polynome([[-3, 2], [2, 1], [1, 0]])(2)
  -3*2**2+2*2+1
  

• Dérivée (Polynome.derive()).

  >>> repr(Polynome([[-3, 2], [2, 1], [1, 0]]).derive())
  Polynome([[-6, 1], [2, 0]], "x", 0)
  

• Caractère réductible ou ordonnable (Polynome.reductible()).

  >>> Polynome([[-3, 2], [2, 1], [1, 1]]).reductible()
  True
  >>> Polynome([[-3, 2], [2, 1], [1, 0]]).reductible()
  False
  

• Caractère ordonnable (Polynome.ordonnable()).

  >>> Polynome([[-3, 2], [2, 1], [1, 0]]).ordonnable()
  False
  >>> Polynome([[-3, 1], [2, 2], [1, 0]]).ordonnable()
  True
  

• Ordonne (Polynome.ordonne()).

  >>> repr(Polynome([[-3, 2], [2, 3], [1, 0]]))
  Polynome([[-3, 2], [2, 3], [1, 0]], "x", 0)
  

• Réduction (partielle) (Polynome.nreduction()). Le résultat dépend de la valeur de l’attribut details du constructeur.

  >>> repr(Polynome([[-3, 2], [2, 2], [1, 0]], details=0).nreduction())
  Polynome([[-1, 2], [1, 0]], "x", 0)
  >>> repr(Polynome([[-3, 2], [2, 2], [1, 0]], details=1).nreduction())
  Polynome([[-1, 2], [1, 0]], "x", 1)
  >>> repr(Polynome([[-3, 2], [2, 2], [1, 0]], details=2).nreduction())
  Polynome([['-3+2', 2], [1, 0]], "x", 2)
  >>> repr(Polynome([[-3, 2], [2, 2], [1, 0]], details=3).nreduction())
  Polynome([['-3+2', 2], [1, 0]], "x", 3)
  

• Factorisation (factoriser()).

  >>> factoriser("Polynome('4x^2+12x+9')")
  Polynome([[2.0, 1]], "x", 0)**2+2*Polynome([[2.0, 1]], "x", 0)*Polynome([[3.0, 0]], "x", 0)+Polynome([[3.0, 0]], "x", 0)**2
  >>> factoriser("Polynome('-4x^2+12x-9')")
  -(Polynome([[2.0, 1]], "x", 0)**2-2*Polynome([[2.0, 1]], "x", 0)*Polynome([[3.0, 0]], "x", 0)+Polynome([[3.0, 0]], "x", 0)**2)
  >>> factoriser("Polynome('4x^2-9')")
  Polynome([[SquareRoot([[1, 4]]), 1]], "x", 0)**2-Polynome([[SquareRoot([[1, 9]]), 0]], "x", 0)**2
  >>> factoriser("Polynome('3x^2-5')")
  Polynome([[SquareRoot([[1, 3]]), 1]], "x", 0)**2-Polynome([[SquareRoot([[1, 5]]), 0]], "x", 0)**2
  >>> factoriser("Polynome('4x^2')")
  Polynome([[2.0, 1]], "x", 0)**2
  >>> factoriser("Polynome('4x')")
  None
  >>> factoriser("Polynome('x+1')*Polynome('x+2')+Polynome('x+1')*Polynome('x+3')")
  Polynome([[1, 1], [1, 0]], "x", 0)*(Polynome([[1, 1], [2, 0]], "x", 0)+Polynome([[1, 1], [3, 0]], "x", 0))
  >>> factoriser("Polynome('x+1')*Polynome('x+2')+Polynome('x+1')")
  Polynome([[1, 1], [1, 0]], "x", 0)*Polynome([[1, 1], [2, 0]], "x", 0)+Polynome([[1, 1], [1, 0]], "x", 0)*1
  >>> factoriser("Polynome('x+1')*Polynome('x+2')+Polynome('x+1')**2")
  Polynome([[1, 1], [1, 0]], "x", 0)*Polynome([[1, 1], [2, 0]], "x", 0)+Polynome([[1, 1], [1, 0]], "x", 0)*Polynome([[1, 1], [1, 0]], "x", 0)
  >>> factoriser("Polynome('x+1')**2-Polynome([[81, 0]], 'x', 3)")
  Polynome([[1, 1], [1, 0]], "x", 0)**2-Polynome([[9.0, 0]], "x", 3)**2
  

4.3.3.5. LaTeX¶

• Conversion en LaTeX (Polynome.__str__()).

  >>> str(Polynome([[-3, 2], [2, 1], [1, 0]]))
  -3\,x^{2}+2\,x+1
  >>> str(Polynome([[-3, 2], [2, 1], [1, 0]], var="z"))
  -3\,z^{2}+2\,z+1
  

4.3.4.1. Nombres¶

• Nombres entiers (suppr0()) : Convertit en entier un flottant égal à un entier.

  >>> from pyromaths.outils.decimaux import suppr0
  >>> suppr0(2.2)
  2.2
  >>> suppr0(2.0)
  2
  >>> suppr0(2)
  2
  

• Conversion de décimaux en chaîne de caractères (decimaux()). Avec l’option mathenv, le décimal est destiné à être affiché dans un environnement mathématique. L’argument peut être une chaîne de caractères ou un Float.

  >>> from pyromaths.outils.decimaux import decimaux
  >>> decimaux(-2.8)
  -2,8
  >>> decimaux("2")
  2
  >>> decimaux("-2.67")
  -2,67
  >>> decimaux("2e1")
  20
  >>> decimaux("34e-1")
  3,4
  >>> decimaux("34e-1", mathenv=True)
  3{,}4
  >>> decimaux("1234567890")
  1\,234\,567\,890
  >>> decimaux("34e-1")
  3,4
  

• Affichage d’un monôme de degré 1 (tex_coef()). Les options (avec les valeurs par défaut) sont :

  • var="" : Variable. Par défaut, aucune variable n’est utilisée ;
  • bplus=False: Ajouter un « + » devant, si nécessaire ;
  • bpn=False: Ajouter des parenthèses, si nécessaire pour un produit (n’ajoute pas de parenthèses autour de 5x, mais le fait pour -5x) ;
  • bpc=False: Ajouter des parenthèses, si nécessaire pour une puissance (n’ajoute pas de parenthèses autour de x, mais le fait pour 5x).

  >>> # Variable
  >>> tex_coef(5)
  5
  >>> tex_coef(5, var='x')
  5\,x
  >>> tex_coef(5, var='y')
  5\,y
  >>> # Signe +
  >>> tex_coef(5, var='x', bplus=True)
  +5\,x
  >>> tex_coef(-5, var='x', bplus=True)
  -5\,x
  >>> # Parenthèses, si nécessaire pour un produit
  >>> tex_coef(5, var='x', bpn=True)
  5\,x
  >>> tex_coef(-5, var='x', bpn=True)
  \left( -5\,x\right)
  >>> # Parenthèses, si nécessaire pour une puissance
  >>> tex_coef(1, var='x', bpn=True, bpc=True)
  x
  >>> tex_coef(5, var='x', bpn=True, bpc=True)
  \left( 5\,x\right)
  

• Affichage de nombres décimaux, radicaux, fractionnaires, infini (TeX()). Des raccourcis sont disponibles avec les commandes suivantes. Les arguments (avec les valeurs par défaut) sont :

  • parenthese=False : Affiche des parenthèses si nécessaire (autour d’un nombre négatif, par exemple).
  • terme=False : Affiche le signe + pour un nombre positif.
  • fractex='\dfrac' : Définit la commande à utiliser pour afficher les fractions.

  >>> TeX(Fraction(7,3)).strip()
  \dfrac{7}{3}
  >>> TeX(Fraction(7,3), fractex='\\frac').strip()
  \frac{7}{3}
  >>> TeX(3).strip()
  3
  >>> TeX(3, terme=True)
  +3
  >>> TeX(-1).strip()
  -1
  >>> TeX(-1, parenthese=True)
  \left(-1\right)
  

• Formate le nombre avec TeX(), sauf s’il est égal à 0 (TeXz()).

  >>> TeXz(0) == ""
  True
  >>> TeXz(2.4)
  2,4
  

• Raccourci pour TeX(nombre, terme=True) (tTeX())

  >>> TeX(3)
  3
  >>> tTeX(3)
  +3
  

• Raccourci pour TeX(nombre, parenthese=True) (:func:`pTeX)

  >>> TeX(-2)
  -2
  >>> pTeX(-2)
  \left(-2\right)
  >>> pTeX(2)
  2
  

• Raccourci pour TeX(nombre, fractex= »frac ») (fTeX())

  >>> TeX(Fraction(6, 7)).strip()
  \dfrac{6}{7}
  >>> fTeX(Fraction(6, 7)).strip()
  \frac{6}{7}
  

• Racine carrée (radicalTeX())

  >>> radicalTeX("4.12")
  \sqrt{4,12}
  >>> radicalTeX(4.12)
  \sqrt{4,12}
  >>> radicalTeX(4000000000000)
  \sqrt{4\,000\,000\,000\,000}