transform construction.mdwn to construction.rst
This commit is contained in:
Lafrite
parent
62ec67ebb2
commit
f4fbda48af
@ -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
|
||||
|
||||
|
||||
|
||||
|
||||
96
docs/construction.rst
Normal file
96
docs/construction.rst
Normal file
@ -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.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user