transform construction.mdwn to construction.rst

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