From 033511b24ec9e14fc8a0a0b10fceee9c72ba0017 Mon Sep 17 00:00:00 2001 From: Lafrite Date: Thu, 23 Apr 2015 11:28:18 +0200 Subject: [PATCH] display code in polynom.rst --- documentation/source/polynom.rst | 179 +++++++++++++++++++++++++++++++ 1 file changed, 179 insertions(+) create mode 100644 documentation/source/polynom.rst diff --git a/documentation/source/polynom.rst b/documentation/source/polynom.rst new file mode 100644 index 0000000..c91aff7 --- /dev/null +++ b/documentation/source/polynom.rst @@ -0,0 +1,179 @@ +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*