Merge branch 'documentation' into dev

docs/construction.mdwn

@@ -1,123 +0,0 @@
-# Explication sur la logique des classes
-
-## Les types
-Ce sont les objects que l'on s'autorise à manipuler dans les expressions. 
-Ces objets doivent pouvoir être afficher en *txt* ou en *tex* avec les méthodes
-    * *__txt__*: affichage en mode text
-    * *__tex__*: affichage pour une compilation latex
-
-### Operator
-Cette classe regroupe les operateurs. Que l'on s'autorise à utiliser. On y accède à partir de deux caractérisiques le symbole et l'arité.
-
-Liste des attributs importants:
-    * arity: nombre d'opérande accepté
-    * priority: où se place l'opérateur dans la règles des priorités parmis les autres opérateurs
-    * isOperator: permet de vérifier que c'est bien un opérateur
-Liste des méthodes importantes:
-    * *__call__*: Permet d'effectuer le calcul sur deux opérandes
-    * *__txt__*: affichage en mode text
-    * *__tex__*: affichage pour une compilation latex
-
-### Number
-Tous les types de "nombres" que l'on va vouloir manipuler. On va essayer de rester le plus proche de la construction mathématiques de ces objets. 
-
-Par défaut, on travaillera avec des anneaux ce qui permettra de construire ensuite le corps des fractions et l'anneau des polynomes (quitte à quotienter) associé.
-
-Pour définir ces anneaux, il faudra contre avoir les méthodes suivantes:
-    * *__add__*
-    * *__radd__*
-    ...
-
-#### Fractions
-
-#### Polynomes
-
-#### Quotient de polynomes (racines)
-
-## Expression
-
-## Render
-
-## Simplify-simplified / compute-child
-
-Dans cette partie, on va expliquer le fonctionnement des mécanismes de simplification des expressions/objets mathématiques.
-
-La simplification des expressions se fait avec les deux méthodes suivantes:
-
-* *simplify()* pour:
-    * un polynôme permet d'accéder à la forme developpée d'un polynôme
-    * une fraction permet d'avoir la fraction irréductible associée
-    * une expression permet de faire tous les calculs possibles de cette expression (à la fin il ne doit y avoir qu'un élément de la liste de tokens)
-* *compute_exp()* pour:
-    * un polynôme ou une fraction fait la même chose que $simplify$.
-    * une expression fait tous les calculs élémentaires de cette expression.
-
-Ces deux méthodes fonctionnent ensuite sur le même principe. Elles vont faire le calcul qui leurs est attribué en enregistrant les étapes dans *steps* puis elles retourneront l'objet de fin de calcul à qui sera assigné les *steps* (ce qui nécessitera par exemple de détourner la classe *int*).
-
-Pour accéder à ces étapes, on utilisera alors la méthode *explain* qui expliqueront les étapes intermédiaires.
-
-### Tentative d'explications
-C'est ce que je voudrai donc le render ne sera peut être pas exactement le même.
-
-Comportement avec les Polynom (ce serait similaire avec les fractions)
-
-    >>> P = Polynom([0,1,2])
-    >>> Q = Polynom([1,1,1])
-    >>> R = P+Q
-    >>> print(R)
-    3x^2 + 2x + 1
-    >>> for i in R.explain():
-    ...     print(i)
-    2x^2 + x + x^2 + x + 1
-    (2 + 1)x^2 + (1+1)x + 1
-    3x^3 + 2x + 1
-
-    >>> P = Polynom([[1,2], [3,4]])
-    >>> Q = P.simplify()
-    >>> print(Q)
-    7x + 3
-    >>> for i in Q.explain():
-    ...     print(i)
-    3x + 4x + 1 + 2
-    (3+4)x + (1+2)
-    7x + 3
-
-Comportement avec les expressions
-
-    >>> e = Expression("1+2*3")
-    >>> e1 = e.compute_exp()
-    >>> e1
-    1 + 6
-    >>> type(e1)
-    Expression
-    >>> for i in e1.explain(): # Peu interessant mais il aurai pu y avoir des calculs de fractions
-    ...     print(i)
-    1 + 2 * 3
-    1 + 6
-    >>> e2 = e.simplify()
-    >>> e2
-    7
-    >>> type(e2)
-    FakeInt
-    >>> for i in e2.explain():
-    ...     print(i)
-    1 + 2 * 3
-    1 + 6
-    7
-    >>> f = Expression("4 - 5")
-    >>> g = e + f
-    >>> g # Les deux expressions ont été concaténée mais aucun calcul n'a été fait
-    < Expression [1, 2, 3, '*', '+', 4, 5, '-', '+']>
-    >>> for i in g.explain():
-    ...     print(i)
-    1 + 2 * 3 + 4 - 5
-    >>> for i in g.simplify().explain():
-    ...     print(i)
-    1 + 2 \times 3 + 4 - 5
-    1 + 6 + ( -1 )
-    7 + ( -1 )
-    6
-
-    
-
-

docs/construction.rst

@@ -0,0 +1,96 @@
+Explication sur la logique des classes
+======================================
+
+Les types
+---------
+
+Ce sont les objets que l'on s'autorise à manipuler dans les
+expressions. Ces objets doivent pouvoir être afficher en *txt* ou en
+*tex* avec les méthodes:
+
+ * __txt__ : affichage en mode text
+ * __tex__ : affichage pour une compilation latex
+
+Operator
+~~~~~~~~
+
+Cette classe regroupe les opérateurs. Que l'on s'autorise à utiliser. On
+y accède à partir de deux caractéristiques le symbole et l'arité.
+
+Liste des attributs importants:
+
+ * arity: nombre d'opérande accepté
+ * priority: où se place l'opérateur dans la règles des priorités parmi
+les autres opérateurs
+ * isOperator: permet de vérifier que c'est bien
+un opérateur
+
+Liste des méthodes importantes:
+
+ * __call__: Permet d'effectuer le calcul sur deux opérandes
+ * __txt__: affichage en mode texte
+ * __tex__: affichage pour une compilation latex
+
+Number
+~~~~~~
+
+Ce sont tous les types de "nombres" que l'on va vouloir manipuler. On essayera
+de rester le plus proche de la construction mathématiques de ces objets.
+
+Par défaut, on travaillera avec des anneaux ce qui permettra de
+construire ensuite le corps des fractions et l'anneau des polynômes
+(quitte à quotienter) associé.
+
+Pour définir ces anneaux, il faudra contre avoir les méthodes suivantes:
+
+  * __add__ 
+  * __radd__ 
+  ...
+
+Fractions
+^^^^^^^^^
+
+Polynomes
+^^^^^^^^^
+
+Quotient de polynomes (racines)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Expression
+----------
+
+Render
+------
+
+Simplify-simplified / compute-child
+-----------------------------------
+
+Dans cette partie, on va expliquer le fonctionnement des mécanismes de
+simplification des expressions/objets mathématiques.
+
+La simplification des expressions se fait avec les deux méthodes
+suivantes:
+
+-  *simplify()* pour:
+
+   -  un polynôme permet d'accéder à la forme développée d'un polynôme.
+   -  une fraction permet d'avoir la fraction irréductible associée.
+   -  une expression permet de faire tous les calculs possibles de cette
+      expression (à la fin il ne doit y avoir qu'un élément de la liste
+      de tokens).
+
+-  *compute_exp()* pour:
+
+   -  un polynôme ou une fraction fait la même chose que `simplify`.
+   -  une expression fait tous les calculs élémentaires de cette
+      expression.
+
+Ces deux méthodes fonctionnent ensuite sur le même principe. Elles vont
+faire le calcul qui leurs est attribué en enregistrant les étapes dans
+*steps* puis elles retourneront l'objet de fin de calcul à qui sera
+assigné les *steps* (ce qui nécessitera par exemple de détourner la
+classe *int*).
+
+Pour accéder à ces étapes, on utilisera alors la méthode *explain* qui
+expliqueront les étapes intermédiaires.
+

docs/polynom.mdwn

@@ -1,55 +0,0 @@
-# Les polynômes
-
-
-## Créer des polynômes
-
-### Générer un polynôme "fixe"
-
-### Générer un polynôme aléatoirement
-
-    >>> P = Polynom.random(["{b}", "{a}"]) # Polynom du type ax + b
-    >>> print(P)
-    - 8 x - 3
-    >>> P = Polynom.random(degree = 2) 
-    >>> print(P)
-    5 x^{  2 } + 4 x - 7
-
-## Manipuler des polynômes
-
-### Les représentations des polynômes
-
-    >>> P = Polynom([1, 2, 3])
-    >>> print(P)
-
-### Évaluer des polynômes
-
-    >>> type(P(3))
-    pymath.expression.Expression
-    >>> for i in P(3).simplify():
-        print(i)
-    3 \times 3^{  2 } + 2 \times 3 + 1
-    3 \times 9 + 6 + 1
-    27 + 6 + 1
-    33 + 1
-    34
-    >>> P(3).simplified()
-    34
-
-
-### Opération et polynômes
-
-    >>> type(P + 1)
-    list
-    >>> for i in (P+1):
-        print(i)
-    3 x^{  2 } + 2 x + 1 + 1
-    3 x^{  2 } + 2 x + 1 + 1
-    3 x^{  2 } + 2 x + 2
-    >>> Q = Polynom([4, 5, 6])
-    >>> for i in (P+Q):
-        print(i)
-    3 x ^ 2 + 6 x ^ 2 + 2 x + 5 x + 1 + 4
-    ( 3 + 6 ) x ^ 2 + ( 2 + 5 ) x + 1 + 4
-    9 x ^ 2 + 7 x + 5
-
-

docs/polynom.rst

@@ -0,0 +1,165 @@
+Les polynômes
+=============
+
+Créer des polynômes
+-------------------
+
+Générer un polynôme "fixe"
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ .. code-block:: python
+    >>> P = Polynom([1,2,3])
+    >>> print(P)
+    3 x ^ 2 + 2 x + 1
+    >>> P = Polynom([1,2,3], letter = 'h')
+    >>> print(P)
+    3 h ^ 2 + 2 h + 1
+    >>> print(P.name)
+    'P'
+    >>> Q = Polynom([1,2,3], name = 'Q')
+    >>> print(Q.name)
+    'Q'
+
+
+
+Générer un polynôme aléatoirement
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ .. code-block:: python
+    >>> P = Polynom.random(["{b}", "{a}"]) # Polynom du type ax + b
+    >>> print(P)
+    - 8 x - 3
+    >>> P = Polynom.random(degree = 2) 
+    >>> print(P)
+    5 x^{  2 } + 4 x - 7
+
+Manipuler des polynômes
+-----------------------
+
+Les représentations des polynômes
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ .. code-block:: python
+    >>> P = Polynom([1, 2, 3])
+    >>> print(P)
+    3 x ^ 2 + 2 x + 1
+
+Évaluer des polynômes
+~~~~~~~~~~~~~~~~~~~~~
+
+Les polynômes peuvent se comporter comme des fonctions, on peut les évaluer. Il est possible de les évaluer sur des nombres, des expressions et même des polynômes.
+
+Évaluer un polynôme avec un entier.
+ .. code-block:: python
+    >>> type(P(3))
+    pymath.expression.Fake_int
+    >>> P(3)
+    34
+    >>> for i in P(3).explain():
+        print(i)
+    3 \times 3^{  2 } + 2 \times 3 + 1
+    3 \times 9 + 6 + 1
+    27 + 6 + 1
+    33 + 1
+    34
+    >>> hp1 = Expression('h+1')
+
+
+Évaluer un polynôme avec une expression.
+ .. code-block:: python
+    >>> type(P(hp1))
+    < <class 'pymath.polynomDeg2.Polynom_deg2'> [6, 8, 3]>
+    >>> print(P(hp1))
+    3 h ^ 2 + 8 h + 6
+    >>> for i in P(hp1).explain():
+    ...     print(i)
+    ...
+    3 ( h + 1 )^{  2 } + 2 ( h + 1 ) + 1
+    3 ( h + 1 ) ( h + 1 ) + 2 h + 2 + 1
+    3 ( h^{  2 } + ( 1 + 1 ) h + 1 ) + 2 h + 2 + 1
+    3 ( h^{  2 } + 2 h + 1 ) + 2 h + 2 + 1
+    3 ( h^{  2 } + 2 h + 1 ) + 2 ( h + 1 ) + 1
+    3 h^{  2 } + 3 \times 2 h + 3 + 2 h + 2 + 1
+    3 h^{  2 } + 6 h + 3 + 2 h + 2 + 1
+    3 h^{  2 } + ( 6 + 2 ) h + 3 + 2 + 1
+    3 h^{  2 } + 8 h + 5 + 1
+    3 h^{  2 } + 8 h + 6
+
+Évaluer un polynôme avec un autre polynôme.
+ .. code-block:: python
+    >>> type(P(P))
+    pymath.polynom.Polynom
+    >>> print(P(P))
+    27 x ^ 4 + 36 x ^ 3 + 36 x ^ 2 + 16 x + 6
+    >>> for i in P(P).explain():
+    ...     print(i)
+    ...
+    3 ( 3 x^{  2 } + 2 x + 1 )^{  2 } + 2 ( 3 x^{  2 } + 2 x + 1 ) + 1
+    3 ( 3 x^{  2 } + 2 x + 1 ) ( 3 x^{  2 } + 2 x + 1 ) + 2 \times 3 x^{  2 } + 2 \times 2 x + 2 + 1
+    3 ( 3 \times 3 x^{  4 } + ( 2 \times 3 + 3 \times 2 ) x^{  3 } + ( 3 + 2 \times 2 + 3 ) x^{  2 } + ( 2 + 2 ) x + 1 ) + 6 x^{  2 } + 4 x + 2 + 1
+    3 ( 9 x^{  4 } + ( 6 + 6 ) x^{  3 } + ( 3 + 4 + 3 ) x^{  2 } + 4 x + 1 ) + 6 x^{  2 } + 4 x + 2 + 1
+    3 ( 9 x^{  4 } + 12 x^{  3 } + ( 7 + 3 ) x^{  2 } + 4 x + 1 ) + 6 x^{  2 } + 4 x + 2 + 1
+    3 ( 9 x^{  4 } + 12 x^{  3 } + 10 x^{  2 } + 4 x + 1 ) + 6 x^{  2 } + 4 x + 2 + 1
+    3 ( 9 x^{  4 } + 12 x^{  3 } + 10 x^{  2 } + 4 x + 1 ) + 2 ( 3 x^{  2 } + 2 x + 1 ) + 1
+    3 \times 9 x^{  4 } + 3 \times 12 x^{  3 } + 3 \times 10 x^{  2 } + 3 \times 4 x + 3 + 2 \times 3 x^{  2 } + 2 \times 2 x + 2 + 1
+    27 x^{  4 } + 36 x^{  3 } + 30 x^{  2 } + 12 x + 3 + 6 x^{  2 } + 4 x + 2 + 1
+    27 x^{  4 } + 36 x^{  3 } + ( 30 + 6 ) x^{  2 } + ( 12 + 4 ) x + 3 + 2 + 1
+    27 x^{  4 } + 36 x^{  3 } + 36 x^{  2 } + 16 x + 5 + 1
+    27 x^{  4 } + 36 x^{  3 } + 36 x^{  2 } + 16 x + 6
+
+
+Opération et polynômes
+~~~~~~~~~~~~~~~~~~~~~~
+
+Les opérations +, -, \* et ^ sont accessibles aux polynômes. Elles renvoient *toujours* un polynôme (même si le résultat est une constante)
+
+ .. code-block:: python
+    >>> type(P + 1)
+    pymath.polynomDeg2.Polynom_deg2
+    >>> for i in (P+1).explain():
+        print(i)
+    3 x^{  2 } + 2 x + 1 + 1
+    3 x^{  2 } + 2 x + 2
+    >>> Q = Polynom([4, 5, 6])
+    >>> for i in (P+Q).explain():
+        print(i)
+    3 x^{  2 } + 2 x + 1 + 6 x^{  2 } + 5 x + 4
+    ( 3 + 6 ) x^{  2 } + ( 2 + 5 ) x + 1 + 4
+    9 x^{  2 } + 7 x + 5
+    >>> Q = Polynom([0,2,3])
+    >>> print(Q)
+    >>> print(P-Q)
+    1
+    >>> type(P-Q)
+    pymath.polynom.Polynom
+
+Dérivation
+~~~~~~~~~~
+
+Il est possible de dériver les polynômes à partir de la méthode *derivate*. De la même façon que pour les opérations, le polynôme dérivé pour s'expliquer avec la méthode *explain*.
+
+ .. code-block:: python
+    >>> P1 = P.derivate()
+    >>> print(P1)
+    6 x + 2
+    >>> for i in P1.explain():
+    ...     print(i)
+    ...
+    2 \times 3 x + 1 \times 2
+    6 x + 2
+    >>> print(P1.name)
+    "P'"
+
+Polynomes du second degré
+-------------------------
+
+Les polynômes du second degré héritent de toutes les méthodes venant de la classe Polynom. Ils ont cependant accès à d'autres méthodes plus spécifiques aux polynômes de ce degré:
+
+    * Accès aux coefficients de façon 'naturelle'
+    * *delta*: discriminant du polynôme.
+    * *alpha*: Abscisse de l'extremum.
+    * *beta*: ordonnée de l'extremum.
+    * *roots*: les racines du polynôme (/!\ utilise *sympy* et ne peux pas expliquer le calcul pour le moment)
+    * *tbl_sgn_header*: en-tête du tableau du tableau de signe écrit pour *TkzTab*
+    * *tbl_sgn*: ligne du tableau de signe pour *TkzTab*
+    * *tbl_variation*: ligne du tableau de variation pour *TkzTab*

docs/tutorial.rst

@@ -0,0 +1,334 @@
+Utilisation de pyMath
+=====================
+
+À quoi sert pyMath?
+-------------------
+
+pyMath est un module python qui permet la manipulation d'expressions
+mathématiques. Voici ce qu'il est capable de faire:
+
+-  *Calculer comme un collégien*: Pour faire de la correction automatisé
+   d'exercice, un logiciel de calcul formel ne suffit pas. Si les étapes
+   de calculs ne sont pas présentes, l'élève ne pourra pas analyser ses
+   erreurs ou s'inspirer de la correction.
+
+ .. code-block:: python
+               >>> from pymath import Expression
+               >>> ajout_fractions = Expression("2 / 5 + 2 / 3")
+               >>> resultat = ajout_fractions.simplify()
+               >>> print(resultat)
+               \frac{ 16 }{ 15 }
+               >>> for i in resultat.explain():
+               ...      print(i)
+               ...
+               \frac{ 2 }{ 5 } + \frac{ 2 }{ 3 }
+               \frac{ 2 \times 3 }{ 5 \times 3 } + \frac{ 2 \times 5 }{ 3 \times 5 }
+               \frac{ 6 }{ 15 } + \frac{ 10 }{ 15 }
+               \frac{ 6 + 10 }{ 15 }
+               \frac{ 16 }{ 15 }
+
+
+-  *Créer des exercices aléatoirement*: Pour faire des devoirs
+   personnels, des fiches de révisions ou des exercices en classe, un
+   générateur d'expressions est inclus.
+
+ .. code-block:: python
+               >>> from pymath import Expression
+               >>> ajout_fraction = Expression.random("{a} + {b} / {c}")
+               >>> print(ajout_fraction)
+               2 + \frac{ 3 }{ 5 }
+
+-  *Gérer différents type de données*: Pour le moment, pyMath est
+   capable de gérer les entiers naturels, les rationnels (sous forme de
+   fractions) et les polynômes. L'utilisation des nombres à virgules et
+   des racines devraient être ajoutés dans les prochaines versions.
+
+ .. code-block:: python
+               >>> from pymath import Fraction
+               >>> une_fraction = Fraction(1,2)
+               >>> print(une_fraction)
+               1 / 2
+               >>> from pymath import Polynom
+               >>> un_polynom = Polynom([1,2,3])
+               >>> print(un_polynom)
+               3 x^{ 2 } + 2 x + 1
+
+-  *Afficher avec deux types de rendus*: Un en mode texte pour
+   l'affichage dans une console. Un deuxième spécialement pour écrire
+   des documents latex.
+
+ .. code-block:: python
+               >>> from pymath import Expression
+               >>> ajout_fractions = Expression("2 / 5 + 2 / 3")
+               >>> for i in ajout_fractions.simpliy().explain():
+               ...      print(i)
+               ...
+               \frac{ 2 }{ 5 } + \frac{ 2 }{ 3 }
+               \frac{ 2 \times 3 }{ 5 \times 3 } + \frac{ 2 \times 5 }{ 3 \times 5 }
+               \frac{ 6 }{ 15 } + \frac{ 10 }{ 15 }
+               \frac{ 6 + 10 }{ 15 }
+               \frac{ 16 }{ 15 }
+               >>> from pymath import txt
+               >>> with Expression.tmp_render(txt):
+               ...      for i in ajout_fractions.simpliy().explain():
+               ...          print(i)
+               ...
+               2 / 5 + 2 / 3
+               ( 2 * 3 ) / ( 5 * 3 ) + ( 2 * 5 ) / ( 3 * 5 )
+               6 / 15 + 10 / 15
+               ( 6 + 10 ) / 15
+               16 / 15
+
+
+Ce module a pour but d'être un outil pour faciliter la construction
+d'exercices et leurs correction. Il a pour but d'être le plus simple
+possible d'utilisation afin que tout le monde avec un minimum de
+connaissance en programmation puisse créer librement des exercices.
+
+Calculer comme un collégien.
+----------------------------
+
+Actuellement le module principal pour faire calculer python comme un
+collégien est *pymath.expression*.
+
+ .. code-block:: python
+    >>> from pymath import Expression
+
+Déclarer une expression
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Un expression peut être initialisée de deux façons différentes: à partir
+d'une chaine de caractères ou à partir de la liste des termes (en
+postfix - cette méthode est essentiellement utilisée pour programmer les
+modules, elle ne sera pas détaillée ici).
+
+ .. code-block:: python
+    >>> un_calcul = Expression("1 + 2 * 3")
+    >>> print(un_calcul)
+    1 + 2 \times 3
+    >>> ajout_fractions = Expression("2 / 5 + 2 / 3")
+    >>> print(ajout_fractions)
+    \frac{ 2 }{ 5 } + \frac{ 2 }{ 3 }
+
+Et si l'on souhaite un rendu plus adapté à la console:
+
+ .. code-block:: python
+    >>> from pymath import txt
+    >>> Expression.set_render(txt)
+    >>> print(un_calcul)
+    1 + 2 * 3
+    >>> print(ajout_fractions)
+    2 / 5 + 2 / 3
+
+Simplification des expressions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Une fois les expressions créées, elles peuvent se réduire en expliquant
+les étapes et en respectant les règles de priorités. Ces étapes de
+calcul sont stockés dans l'objet résultat du calcul et sont accéssibles
+à travers la méthode *explain*. Les exemples suivants seront données
+avec un rendu texte.
+
+ .. code-block:: python
+    >>> from pymath import Expression
+    >>> from pymath import txt
+    >>> Expression.set_render(txt)
+
+    >>> exp = Expression("1 + 2 * 3")
+    >>> exp_simplifiee = exp.simplify()
+    >>> print(exp_simplifiee)
+    7
+    >>> for i in exp_simplifiee.explain():
+    ...     print(i)
+    ... 
+    1 + 2 * 3
+    1 + 6
+    7
+        
+
+Les opérations autorisées sont les opérations "classique": + - * / ^.
+L'utilisation des parenthèses est aussi gérée.
+
+ .. code-block:: python
+    >>> exp = Expression("1 + 2 / 5")
+    >>> for i in exp.simplify().explain():
+    ...     print(i)
+    ... 
+    1 + 2 / 5
+    ( 1 * 5 ) / ( 1 * 5 ) + ( 2 * 1 ) / ( 5 * 1 )
+    ( 5 + 2 ) / 5
+    7 / 5
+
+    >>> exp = Expression("(2 + 4)(3 - 4 * 2)")
+    >>> for i in exp.simplify().explain():
+    ...     print(i)
+    ... 
+    ( 2 + 4 ) ( 3 - ( 4 * 2 ) )
+    6 * ( 3 - 8 )
+    6 * ( -5 )
+    -30
+
+Type de variables et opérations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+On peut vouloir créer directement des objets (fractions ou polynômes)
+sans passer par le module expression (voir `fraction <fraction.rst>`__
+et `polynom <polynom.rst>`__ pour plus de details)
+
+ .. code-block:: python
+    >>> from pymath import Fraction
+    >>> fraction1 = Fraction(1,2)
+    >>> fraction2 = Fraction(2,3)
+    >>> print(fraction1)
+    1 / 2
+    >>> from pymath import Polynom
+    >>> p = Polynom([1,2,3])
+    >>> print(p)
+    3 x ^ 2 + 2 x + 1
+    >>> q = Polynom([0,0,1])
+    x ^ 2
+
+On peut effectuer des opérations entre les Expressions.
+
+ .. code-block:: python
+    >>> fraction_expression = Expression("2 / 3")
+    >>> autre_fraction_expression = Expression("4 / 9")
+    >>> print(fraction_expression + autre_fraction_expression)
+    2 / 3 + 4 / 9
+
+On remarque qu'un opération sur des expressions, ne fait pas de calculs.
+Elle ne fait que "concaténer" les listes des tokens.
+
+À l'inverse, les opérations sur les fractions ou les polynômes renvoient
+la liste des étapes jusqu'à leur forme simplifiée
+
+ .. code-block:: python
+    >>> addition_fraction = fraction1 + fraction2
+    >>> print(addition_fraction)
+    7 / 6
+    >>> for i in addition_fraction.explain():
+    ...     print(i)
+    ...
+    1 * 3 / 2 * 3 + 2 * 2 / 3 * 2
+    ( 3 + 4 ) / 6
+    7 / 6
+    >>> r = p + q
+    >>> print(r)
+    4 x ^ 2 + 2 x + 1
+    >>> for i in r.explain():
+    ...     print(i)
+    ...
+    3 x ^ 2 + x ^ 2 + 2 x + 1
+    ( 3 + 1 ) x ^ 2 + 2 x + 1
+    4 x ^ 2 + 2 x + 1
+
+Différents rendus
+~~~~~~~~~~~~~~~~~
+
+Comme dit dans l'introduction, il y a deux types de rendus: un rendu
+texte (utilisé depuis le début) et un rendu latex.
+
+Voici un exemple de l'utilisation du rendu latex (par défaut).
+
+ .. code-block:: python
+    >>> exp = Expression("1 + 2 / 5")
+    >>> for i in exp.simplify().explain():
+    ...     print(i)
+    ... 
+    1  +  \frac{ 2 }{ 5 }
+    \frac{ 1 \times 5 }{ 1 \times 5 }  +  \frac{ 2 \times 1 }{ 5 \times 1 }
+    \frac{ 5  +  2 }{ 5 }
+    \frac{ 7 }{ 5 }
+
+Pour changer le rendu, on importe le rendu depuis *pymath.render* et on
+appelle la méthode de classe d'Expression *set_render*.
+
+Voici un exemple d'utilisation du rendu txt
+
+ .. code-block:: python
+    >>> from pymath import txt
+    >>> Expression.set_render(txt)
+    >>> exp = Expression("1 + 2 / 5")
+    >>> for i in exp.simplify().explain():
+    ...     print(i)
+    ... 
+    2 / 5 + 2 / 3
+    2 * 3 / 5 * 3 + 2 * 5 / 3 * 5
+    ( 6 + 10 ) / 15
+    16 / 15
+
+Générer des expressions aléatoirement.
+--------------------------------------
+
+Créer un expression
+~~~~~~~~~~~~~~~~~~~
+
+Pour créer une expression il faut au moins une chose: la forme de
+l'expression. Toutes les lettres entre accolades seront remplacées par
+des valeurs aléatoires (par défaut entre -10 et 10 et non nulles).
+
+ .. code-block:: python
+    >>> form = "2* {a} + 3"
+    >>> expression_aleatoire = Expression.random(form)
+    >>> print(expression_aleatoire)
+    '2 \times 9  +  3'
+    >>> print(Expression.random(form,val_min = 30, val_max = 40))
+    '2 \times 31  +  3'
+
+Créer une expression avec conditions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Parfois il peut être nécessaire d'imposer des conditions sur les
+éléments à générer pour créer des exercices spécifiques.
+
+ .. code-block:: python
+    >>> form = "{a} / {b} + {c} / {d}"
+    >>> conditions = ["abs({b}) != 1", "{d} > 1", "{b} != {d}", "gcd({a},{b}) == 1", "gcd({c},{d}) == 1"]
+    >>> addition_fraction_alea = Expression.random(form, conditions)
+    >>> print(addition_fraction_alea)
+    '\frac{ 4 }{ 5 }  +  \frac{ 9 }{ 7 }'
+
+La méthode pour créer les valeurs avec des conditions est la méthode par
+rejet. Elle n'est pas très efficace et rien n'est encore prévu dans le
+cas où aucune valeur n'est possible.
+
+Opérations avec les valeurs générées
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Pour éviter de faire tourner la méthode par rejet trop longtemps, il est
+possible de faire des calculs avec les valeurs générées.
+
+ .. code-block:: python
+    >>> form = "{a} / {b} + {c} / {k*b}"
+    >>> conditions = ["abs({b}) != 1", "{k} > 1", "{b} != {d}", "gcd({a},{b}) == 1", "gcd({c},{k*b}) == 1"]
+    >>> random_frac_add_generator = RdExpression(form, conditions)
+    >>> print(random_frac_add_generator())
+    \frac{ -9 }{ 7 }  +  \frac{ 1 }{ 28 }
+
+Rendu des expressions
+~~~~~~~~~~~~~~~~~~~~~
+
+On peut vouloir ne pas passer par la classe Expression pour obtenir
+notre expression (si l'on veut utiliser la racine carré par exemple, ou
+pour créer n'importe quoi qui ne fait pas intervenir d'expression).
+Ainsi pymath ne gère plus le rendu de l'expression ni son calcul.
+
+La fonction qui permet de faire cela est *random_str*:
+
+ .. code-block:: python
+    >>> from pymath import random_str
+    >>> form = "{a} / {b} + {c} / {k*b}"
+    >>> conditions = ["abs({b}) != 1", "{d} > 1", "{b} != {d}", "gcd({a},{b}) == 1", "gcd({c},{k*b}) == 1"]
+    >>> str_addition_fraction = random_str(form, conditions)
+    >>> type(str_addition_fraction)
+    str
+    >>> print(str_addition_fraction)
+    -2 / 5 + -8 / 35
+
+    >>> form = "A({a},{b}), B({2*a}, {3*b})"
+    >>> points_alea = random_str(form)
+    >>> points_alea
+    'A(7,5), B(14, 15)'
+
+On remarque le défaut d'utiliser cette forme, le rendu est moins bien
+fait (dans l'exemple, il n'y a pas de parenthèses autour du -8).