From ac0be63a836fa142f528f9bea642ce495721d48f Mon Sep 17 00:00:00 2001 From: Lafrite Date: Thu, 23 Apr 2015 10:04:56 +0200 Subject: [PATCH] transform construction.mdwn to construction.rst --- docs/construction.mdwn | 123 ----------------------------------------- docs/construction.rst | 96 ++++++++++++++++++++++++++++++++ 2 files changed, 96 insertions(+), 123 deletions(-) delete mode 100644 docs/construction.mdwn create mode 100644 docs/construction.rst diff --git a/docs/construction.mdwn b/docs/construction.mdwn deleted file mode 100644 index d713754..0000000 --- a/docs/construction.mdwn +++ /dev/null @@ -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 - - - - diff --git a/docs/construction.rst b/docs/construction.rst new file mode 100644 index 0000000..9d944b7 --- /dev/null +++ b/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. +