Documentation de Pyromaths 18.6-2

3.2.4. jinja2 — Utilitaires à utiliser avec les templates jinja2

«  3.2.3. Conversions — Fonctions de conversions   ::   Contenu   ::   3.2.5. Priorites3 — Évaluation d’une expression calculatoire  »

3.2.4. jinja2 — Utilitaires à utiliser avec les templates jinja2

Outils à utiliser avec les exercices utilisant Jinja2.

pyromaths.outils.jinja2.facteur(nombre, court='', parentheses=False, zero=False, arrondi=None, signe=False, operation=False, produit=False, variable='')[source]

Renvoit le code \(\LaTeX\) correspondant au nombre, dans un \\numprint{}, en gérant de nombreux cas particuliers.

Les cas d’utilisation de cette fonction sont détaillés dans le tutoriel pour écrire un nouvel exercice.

En utilisant les arguments, cette fonction permet de prendre en compte les arrondis, et de nombreux cas particuliers (dans chaque cas, c’est le 3 qui est destiné à être rendu par cette fonction.

  • ajout de parenthèses uniquement si nécessaire (produit 2×3 et 2×(-3) plutôt que 2×-3 ou 2×(3)) ;
  • ajout du signe, même s’il est positif (produit 1+3x et 1-3x plutôt que 1 3x ou 1+-3x) ;
  • n’affiche pas le nombre 1, et seulement le signe de -1 (produit x et -x plutôt que 1x et -1x) ;
  • n’affiche pas l’opérande nulle d’un produit (produit 2 plutôt que 2+0x) ;
  • etc.

Le séparateur décimal est le point, mais celui-ci sera converti en une virgule par \\numprint{}.

Paramètres:
  • nombre (float) – Nombre à formatter.
  • court (str) – Version courte des arguments (voir plus loin).
  • parentheses (boolean) – Encadre le nombre avec des parenthèses, s’il est négatif (utile pour produire 2×(-3) plutôt que 2×3).
  • arrondi (int) – Arrondi le nombre. L’argument est le nombre de chiffres après la virgule à utiliser. Mettre cet argument à None pour ne pas arrondir.
  • zero (boolean) – Ajoute des zéros à la fin du nombre pour avoir autant de chiffres que défini par arrondi (par exemple, avec cette option et un arrondi au centième, 2 devient 2.00).
  • signe (boolean) – Produit le signe, même si le nombre est positif (produit alors un +).
  • operation (boolean) – Indique que le signe plus ou moins est une opération (comme 2-3) et non pas un opérateur unaire (comme 2×(-3)). Cela a pour effet d’espacer un peu le signe du nombre.
  • produit (boolean) – Le facteur est une opérande d’un produit : le nombre 1 ne doit pas être affiché ; du nombre -1, on ne conserve que le signe ; rien n’est affiché si le nombre est 0 (pour produire x, -x ou rien plutôt que 1x, -1x, 0x).
  • variable (str) – Seconde opérande du produit. Doit être du code \(LaTeX\) valide.
Retourne:

Le nombre, formatté comme du code \(LaTeX\).

Type retourné:

str

Dépendances entre arguments:
 
  • Le comportement n’est pas défini si les arguments operation et parentheses sont utilisées en même temps.
Version courte des arguments:
 

Pour que les arguments soient moins verbeux, il est possible d’utiliser la version courte des arguments. Par exemple, facteur(2, produit=True, parentheses=True, arrondi=3) peut s’écrire comme facteur(2, '*p3').

Cet argument est une chaîne de caractères, chaque caractère « activant » une option longue. Par exemple *p3 active les options produit, parentheses et arrondi=3. L’ordre des caractères n’a aucune importance. Plusieurs comportement sont non-définis :

  • présence de caractères ne correspondant à aucun argument ;
  • utilisation conjointe des arguments courts et longs ;
  • utilisation de plusieurs chiffres (pour l’argument arrondi).

Les arguments sont :

  • p: parentheses ;
  • z: zero ;
  • s: signe ;
  • o: operation ;
  • *: produit ;
  • chiffres 0 à 9: arrondi à l’entier correspondant ;
  • x, X, y, Y: Raccourcis pour (respectivement) variable="x", variable="x^2", variable="y", variable="y^2".
Exemples:
Cas de base
>>> from pyromaths.outils.jinja2 import facteur
>>> facteur(2)
\numprint{2}
>>> facteur(2.0)
\numprint{2}
>>> facteur(2.3)
\numprint{2.3}
>>> facteur(-122.0)
\numprint{-122}
Arrondi
>>> facteur(12345.6789, arrondi=None)
\numprint{12345.6789}
>>> facteur(12345.6789, arrondi=0)
\numprint{12346}
>>> facteur(12345.6789, arrondi=2)
\numprint{12345.68}
>>> facteur(.6789, arrondi=0)
\numprint{1}
>>> facteur(.6789, arrondi=2)
\numprint{0.68}
Zéro
>>> facteur(12345.6789, arrondi=None, zero=True)
\numprint{12345.6789}
>>> facteur(12345, arrondi=2, zero=True)
\numprint{12345.00}
>>> facteur(12345, arrondi=2, zero=False)
\numprint{12345}
>>> facteur(12345.7, arrondi=2, zero=True)
\numprint{12345.70}
>>> facteur(12345.7, arrondi=2, zero=False)
\numprint{12345.7}
Parenthèse
>>> facteur(-2, parentheses=True)
\left(\numprint{-2}\right)
>>> facteur(2, parentheses=True)
\numprint{2}
Signe
>>> facteur(-2, signe=True)
\numprint{-2}
>>> facteur(2, signe=True)
\numprint{+2}
>>> facteur(2, signe=False)
\numprint{2}
Opération
>>> facteur(-2, operation=False)
\numprint{-2}
>>> facteur(2, signe=True, operation=False)
\numprint{+2}
>>> facteur(-2, operation=True)
-\numprint{2}
>>> facteur(2, signe=True, operation=True)
+\numprint{2}
Produit
>>> facteur(1, produit=True, variable="x")
x
>>> facteur(-1, produit=True, variable="x")
-x
>>> facteur(0, produit=True, variable="x")

>>> facteur(1, produit=False, variable="x")
\numprint{1}\,x
Variable
>>> facteur(2, variable="x")
\numprint{2}\,x
>>> facteur(-1, produit=True, variable="x")
-x
Version courte des arguments
>>> facteur(-2, court="2zXo")
-\numprint{2.00}\,x^2
>>> facteur(-2, court="2zXp")
\left(\numprint{-2.00}\,x^2\right)
>>> facteur(-2, court="2zY")
\numprint{-2.00}\,y^2
>>> facteur(-1, court="y*")
-y
>>> facteur(1, court="p*x")
x
>>> facteur(-1, court="p*x")
\left(-x\right)
>>> facteur(-2, court="p*x")
\left(\numprint{-2}\,x\right)
>>> facteur(2, court="p*x")
\numprint{2}\,x
>>> facteur(1, court="s*x")
+x
pyromaths.outils.jinja2.iter_facteurs(liste, short)[source]

Applique facteur() à une liste de nombres.

  • Les éléments peuvent être des nombres, ou pas (auquel cas la fonction str() est appliquée).
  • L’argument short est transmis à facteur().
pyromaths.outils.jinja2.matrice(listes, short='')[source]

Renvoit le code LaTeX d’une matrice.

  • La matrice est sous la forme d’une liste de lignes (où chaque ligne est une liste de coefficients).
  • L’argument short est transmis à facteur().
>>> from pyromaths.outils.jinja2 import matrice
>>> matrice([[1, 2], [3, 4]])
\begin{pmatrix}\numprint{1} & \numprint{2}\\\numprint{3} & \numprint{4}\\\end{pmatrix}

«  3.2.3. Conversions — Fonctions de conversions   ::   Contenu   ::   3.2.5. Priorites3 — Évaluation d’une expression calculatoire  »