From 62ec67ebb2a4b930561f61bac3e5c94abdb9f6b1 Mon Sep 17 00:00:00 2001 From: Lafrite Date: Thu, 23 Apr 2015 09:54:21 +0200 Subject: [PATCH 1/3] transform tutorial.md to tutorial.rst --- docs/tutorial.rst | 334 ++++++++++++++++++++++++++++++++++++++++++++++ setup.py | 1 + 2 files changed, 335 insertions(+) create mode 100644 docs/tutorial.rst 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). diff --git a/setup.py b/setup.py index f084faf..9d8eb67 100644 --- a/setup.py +++ b/setup.py @@ -8,4 +8,5 @@ setup(name='pyMath', author='Benjamin Bertrand', author_email='lafrite@poneyworld.net', packages=['pymath'], + install_requires=['pyparsing', 'sympy'], ) From f4fbda48af6338c68b2c71c9967334bca6076526 Mon Sep 17 00:00:00 2001 From: Lafrite Date: Thu, 23 Apr 2015 10:04:56 +0200 Subject: [PATCH 2/3] 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. + From 3984f101bd481db447ba038612770d5ebec051b2 Mon Sep 17 00:00:00 2001 From: Lafrite Date: Thu, 23 Apr 2015 10:40:02 +0200 Subject: [PATCH 3/3] finish translate doc from markdown to ReST --- docs/{fraction.mdwn => fraction.rst} | 0 docs/polynom.mdwn | 55 ------ docs/polynom.rst | 165 +++++++++++++++++ docs/tutorial.mdwn | 253 --------------------------- 4 files changed, 165 insertions(+), 308 deletions(-) rename docs/{fraction.mdwn => fraction.rst} (100%) delete mode 100644 docs/polynom.mdwn create mode 100644 docs/polynom.rst delete mode 100644 docs/tutorial.mdwn 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.mdwn b/docs/tutorial.mdwn deleted file mode 100644 index 1ed1ae4..0000000 --- a/docs/tutorial.mdwn +++ /dev/null @@ -1,253 +0,0 @@ -# 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. - - >>> from pymath.expression 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 + 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. - - >>> from pymath.expression import Expression - >>> ajout_fraction = Expression.random("{a} + {b} / {c}") - >>> print(ajout_fraction) - 5 + \frac{ -7 }{ 4 } - -* *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. - - >>> from pymath.fraction import Fraction - >>> une_fraction = Fraction(1,2) - >>> print(une_fraction) - 1 / 2 - >>> from pymath.polynom 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. - - >>> from pymath.expression 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 + 10 }{ 15 } - \frac{ 16 }{ 15 } - >>> from pymath.render import txt - >>> with Expression.tmp_render(txt): - ... for i in ajout_fractions.simpliy(): - ... print(i) - ... - 2 / 5 + 2 / 3 - 2 * 3 / 5 * 3 + 2 * 5 / 3 * 5 - ( 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*. - - >>> from pymath.expression 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). - - >>> 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: - - >>> from pymath.render import txt - >>> Expression.set_render(txt) - >>> un_calcul.render() - 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. - - >>> from pymath.expression import Expression - >>> from pymath.renders 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. - - >>> 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](fraction.mdwn) et [polynom](polynom.mdwn) pour plus de details) - - >>> from pymath.fraction import Fraction - >>> fraction1 = Fraction(1,2) - >>> fraction2 = Fraction(2,3) - >>> print(fraction1) - 1 / 2 - >>> from pymath.polynom 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. - - >>> fraction_expression = Expression("2 / 3") - >>> autre_fraction_expression = Expression("4 / 9") - >>> print(fraction_expression + autre_fraction_expression) - 2 / 3 + 4 / 9 - -les opérations sur les fractions ou les polynômes renvoient la liste des étapes jusqu'à leur forme simplifiée - - >>> 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). - - >>> 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 import 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 - - >>> from pymath.render 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). - - >>> 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. - - >>> 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. - - >>> 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*: - - >>> from pymath.random_expression 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).