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. + diff --git a/docs/fraction.mdwn b/docs/fraction.rst similarity index 100% rename from docs/fraction.mdwn rename to docs/fraction.rst diff --git a/docs/polynom.mdwn b/docs/polynom.mdwn deleted file mode 100644 index a265841..0000000 --- a/docs/polynom.mdwn +++ /dev/null @@ -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 - - diff --git a/docs/polynom.rst b/docs/polynom.rst new file mode 100644 index 0000000..d2a3af8 --- /dev/null +++ b/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)) + < [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* diff --git a/docs/tutorial.rst b/docs/tutorial.rst new file mode 100644 index 0000000..8655098 --- /dev/null +++ b/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 `__ +et `polynom `__ 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).