124 lines
4.0 KiB
Markdown
124 lines
4.0 KiB
Markdown
# 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 canonique 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ée 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
|
|
|
|
|
|
|
|
|