- À propos des polynômes avec Poly en SymPy
- Créer un polynôme avec Poly
- Connaître le degré et les coefficients d'un polynôme
- Accéder aux termes et aux monômes d'un polynôme
- Effectuer des opérations sur les polynômes
- Effectuer une division polynomiale
- Évaluer et transformer un polynôme
- Manipuler des polynômes à plusieurs variables
- Factoriser et rechercher les racines d'un polynôme
- À retenir !
1. À propos des polynômes avec Poly en SymPy
La bibliothèque SymPy permet de manipuler directement des expressions algébriques, mais elle propose également la classe Poly, spécialement conçue pour représenter et manipuler des polynômes. Un objet Poly fournit des méthodes permettant d'obtenir facilement le degré, les coefficients, les monômes et les termes d'un polynôme, mais aussi d'effectuer des divisions et d'autres opérations polynomiales.
Le programme suivant crée un premier objet Poly à partir d'une expression en x.
1 2 3 4 5 | from sympy import symbols, Poly x = symbols("x") P = Poly(x**3 + 2*x**2 - 5*x + 3, x) print(P) |
Sortie :
1 | Poly(x**3 + 2*x**2 - 5*x + 3, x, domain='ZZ') |
SymPy indique que P est un polynôme en x. Le domaine ZZ signifie ici que ses coefficients appartiennent aux entiers.
Un objet Poly est différent d'une expression SymPy ordinaire. La méthode as_expr() permet de récupérer l'expression algébrique associée au polynôme.
1 2 3 4 5 6 | from sympy import symbols, Poly x = symbols("x") P = Poly(x**2 + 3*x + 2, x) expression = P.as_expr() print(expression) |
Sortie :
1 | x**2 + 3*x + 2 |
Nous pouvons ainsi passer facilement d'une représentation sous forme de polynôme à une expression SymPy classique.
2. Créer un polynôme avec Poly
La syntaxe générale est Poly(expression, variable). L'expression doit être polynomiale par rapport à la variable indiquée. SymPy analyse alors automatiquement les coefficients et détermine leur domaine.
Le programme suivant crée un polynôme de degré 4.
1 2 3 4 5 | from sympy import symbols, Poly x = symbols("x") P = Poly(2*x**4 - 3*x**2 + 7*x - 1, x) print(P) |
Sortie :
1 | Poly(2*x**4 - 3*x**2 + 7*x - 1, x, domain='ZZ') |
Le terme en x³ est absent, mais cela ne pose aucun problème. Son coefficient est simplement égal à zéro.
Les coefficients d'un polynôme ne sont pas nécessairement des entiers. Dans l'exemple suivant, nous utilisons des coefficients rationnels exacts avec Rational.
1 2 3 4 5 | from sympy import symbols, Poly, Rational x = symbols("x") P = Poly(Rational(1, 2)*x**2 + Rational(3, 4)*x + 1, x) print(P) |
Sortie :
1 | Poly(1/2*x**2 + 3/4*x + 1, x, domain='QQ') |
Le domaine QQ indique que les coefficients sont des nombres rationnels.
3. Connaître le degré et les coefficients d'un polynôme
Un objet Poly possède plusieurs méthodes permettant d'analyser sa structure. La méthode degree() retourne le degré du polynôme, tandis que LC() retourne son coefficient dominant.
Le programme suivant récupère le degré et le coefficient dominant d'un polynôme.
1 2 3 4 5 6 7 | from sympy import symbols, Poly x = symbols("x") P = Poly(5*x**4 - 2*x**3 + 7*x - 9, x) print("Degré :", P.degree()) print("Coefficient dominant :", P.LC()) |
Sortie :
1 2 | Degré : 4 Coefficient dominant : 5 |
La méthode all_coeffs() retourne tous les coefficients du polynôme dans l'ordre décroissant des puissances. Les coefficients nuls correspondant aux puissances absentes sont également présents.
1 2 3 4 5 | from sympy import symbols, Poly x = symbols("x") P = Poly(5*x**4 - 2*x**3 + 7*x - 9, x) print(P.all_coeffs()) |
Sortie :
1 | [5, -2, 0, 7, -9] |
Le nombre 0 correspond au coefficient de x², puisque ce terme n'apparaît pas dans le polynôme.
La méthode coeffs() permet au contraire de récupérer uniquement les coefficients associés aux termes effectivement présents.
1 2 3 4 5 | from sympy import symbols, Poly x = symbols("x") P = Poly(5*x**4 - 2*x**3 + 7*x - 9, x) print(P.coeffs()) |
Sortie :
1 | [5, -2, 7, -9] |
La différence entre all_coeffs() et coeffs() est donc importante lorsqu'un polynôme possède des puissances manquantes.
4. Accéder aux termes et aux monômes d'un polynôme
En plus des coefficients, Poly permet d'obtenir les monômes et les termes qui constituent un polynôme. La méthode monoms() retourne les exposants des monômes présents.
Le programme suivant affiche les monômes d'un polynôme en une variable.
1 2 3 4 5 | from sympy import symbols, Poly x = symbols("x") P = Poly(3*x**4 + 2*x**2 - 5, x) print(P.monoms()) |
Sortie :
1 | [(4,), (2,), (0,)] |
Les tuples (4,), (2,) et (0,) représentent respectivement les monômes x⁴, x² et 1.
La méthode terms() retourne simultanément les monômes et leurs coefficients.
1 2 3 4 5 | from sympy import symbols, Poly x = symbols("x") P = Poly(3*x**4 + 2*x**2 - 5, x) print(P.terms()) |
Sortie :
1 | [((4,), 3), ((2,), 2), ((0,), -5)] |
Chaque élément contient un tuple représentant le monôme suivi de son coefficient. Cette représentation est particulièrement pratique pour analyser un polynôme par programmation.
5. Effectuer des opérations sur les polynômes
Les objets Poly peuvent être additionnés, soustraits et multipliés comme des expressions algébriques. Le résultat reste un objet Poly lorsque les polynômes sont compatibles.
Le programme suivant additionne deux polynômes.
1 2 3 4 5 6 7 | from sympy import symbols, Poly x = symbols("x") P = Poly(x**2 + 2*x + 1, x) Q = Poly(2*x**2 - x + 3, x) R = P + Q print(R) |
Sortie :
1 | Poly(3*x**2 + x + 4, x, domain='ZZ') |
Les coefficients correspondant aux mêmes puissances de x sont automatiquement additionnés.
Le produit de deux objets Poly s'effectue également avec l'opérateur *.
1 2 3 4 5 6 7 | from sympy import symbols, Poly x = symbols("x") P = Poly(x + 1, x) Q = Poly(x - 2, x) R = P*Q print(R) |
Sortie :
1 | Poly(x**2 - x - 2, x, domain='ZZ') |
Le produit reste représenté comme un objet Poly, ce qui permet de poursuivre les traitements polynomiaux.
6. Effectuer une division polynomiale
La classe Poly fournit la méthode div() pour effectuer une division euclidienne de polynômes. Cette opération retourne deux objets : le quotient et le reste.
Le programme suivant divise x³ - 1 par x - 1.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, Poly x = symbols("x") P = Poly(x**3 - 1, x) Q = Poly(x - 1, x) quotient, reste = P.div(Q) print("Quotient :", quotient) print("Reste :", reste) |
Sortie :
1 2 | Quotient : Poly(x**2 + x + 1, x, domain='ZZ') Reste : Poly(0, x, domain='ZZ') |
Le reste est nul, ce qui montre que x - 1 divise exactement x³ - 1.
Lorsque la division n'est pas exacte, la méthode retourne le reste correspondant.
1 2 3 4 5 6 7 8 9 | from sympy import symbols, Poly x = symbols("x") P = Poly(x**3 + 2*x + 1, x) Q = Poly(x**2 + 1, x) quotient, reste = P.div(Q) print("Quotient :", quotient) print("Reste :", reste) |
Sortie :
1 2 | Quotient : Poly(x, x, domain='ZZ') Reste : Poly(x + 1, x, domain='ZZ') |
Nous avons donc la relation P = Q × quotient + reste, exactement comme dans une division euclidienne classique.
7. Évaluer et transformer un polynôme
La méthode eval() permet d'évaluer directement un objet Poly pour une valeur donnée de sa variable. Cette opération évite de convertir préalablement le polynôme en expression classique.
Le programme suivant calcule la valeur de P(x) = x² + 3x + 2 pour x = 2.
1 2 3 4 5 6 | from sympy import symbols, Poly x = symbols("x") P = Poly(x**2 + 3*x + 2, x) resultat = P.eval(2) print(resultat) |
Sortie :
1 | 12 |
La classe Poly permet également de calculer directement la dérivée polynomiale avec la méthode diff().
1 2 3 4 5 6 | from sympy import symbols, Poly x = symbols("x") P = Poly(3*x**4 - 2*x**2 + 5*x - 1, x) derivee = P.diff() print(derivee) |
Sortie :
1 | Poly(12*x**3 - 4*x + 5, x, domain='ZZ') |
La dérivée obtenue reste un objet Poly. Nous pouvons donc continuer à utiliser directement les méthodes spécifiques aux polynômes.
Pour récupérer ensuite une expression SymPy classique, il suffit d'utiliser as_expr().
1 2 3 4 5 6 | from sympy import symbols, Poly x = symbols("x") P = Poly(x**3 + 2*x - 1, x) expression = P.as_expr() print(expression) |
Sortie :
1 | x**3 + 2*x - 1 |
Cette conversion est utile lorsqu'une fonction SymPy attend une expression générale plutôt qu'un objet Poly.
8. Manipuler des polynômes à plusieurs variables
La classe Poly peut représenter des polynômes à plusieurs variables. Il suffit d'indiquer les différents générateurs après l'expression lors de la création du polynôme.
Le programme suivant crée un polynôme en deux variables x et y.
1 2 3 4 5 | from sympy import symbols, Poly x, y = symbols("x y") P = Poly(x**2 + 2*x*y + 3*y**2 + 1, x, y) print(P) |
Sortie :
1 | Poly(x**2 + 2*x*y + 3*y**2 + 1, x, y, domain='ZZ') |
Les variables x et y sont les générateurs du polynôme. La méthode total_degree() permet d'obtenir son degré total.
1 2 3 4 5 | from sympy import symbols, Poly x, y = symbols("x y") P = Poly(x**2*y + x*y**2 + y + 1, x, y) print(P.total_degree()) |
Sortie :
1 | 3 |
Les termes x²y et xy² ont chacun un degré total égal à 3.
Pour un polynôme multivarié, degree() peut également être utilisé pour connaître le degré par rapport à une variable particulière.
1 2 3 4 5 6 7 | from sympy import symbols, Poly x, y = symbols("x y") P = Poly(x**3*y + x*y**4 + y**2, x, y) print("Degré en x :", P.degree(x)) print("Degré en y :", P.degree(y)) |
Sortie :
1 2 | Degré en x : 3 Degré en y : 4 |
Cette distinction entre degré total et degré par rapport à une variable est fondamentale pour l'étude des polynômes multivariés.
9. Factoriser et rechercher les racines d'un polynôme
Un objet Poly peut être converti en expression afin d'utiliser les fonctions générales de SymPy telles que factor(). Cette fonction permet de mettre en évidence les facteurs d'un polynôme.
Le programme suivant factorise le polynôme x³ - 6x² + 11x - 6.
1 2 3 4 5 6 | from sympy import symbols, Poly, factor x = symbols("x") P = Poly(x**3 - 6*x**2 + 11*x - 6, x) resultat = factor(P.as_expr()) print(resultat) |
Sortie :
1 | (x - 3)*(x - 2)*(x - 1) |
La factorisation permet de voir immédiatement que les racines sont 1, 2 et 3.
La méthode all_roots() permet également d'obtenir directement toutes les racines d'un polynôme univarié, en tenant compte de leur multiplicité.
1 2 3 4 5 6 | from sympy import symbols, Poly x = symbols("x") P = Poly(x**3 - 6*x**2 + 11*x - 6, x) racines = P.all_roots() print(racines) |
Sortie :
1 | [1, 2, 3] |
Lorsqu'une racine est multiple, elle apparaît plusieurs fois dans la liste retournée par all_roots().
1 2 3 4 5 6 | from sympy import symbols, Poly x = symbols("x") P = Poly((x - 1)**2*(x + 2), x) racines = P.all_roots() print(racines) |
Sortie :
1 | [-2, 1, 1] |
La racine 1 apparaît deux fois car elle est de multiplicité 2.
10. À retenir !
La classe Poly de SymPy fournit une représentation spécialement conçue pour la manipulation des polynômes. Elle offre des méthodes précises pour étudier leur degré, leurs coefficients, leurs termes, leurs monômes et leurs racines, ainsi que pour effectuer des opérations polynomiales.
- Poly(expression, x) crée un polynôme en x.
- as_expr() transforme un objet Poly en expression SymPy classique.
- degree() retourne le degré d'un polynôme.
- LC() retourne son coefficient dominant.
- all_coeffs() retourne tous les coefficients, y compris les coefficients nuls des puissances manquantes.
- coeffs(), monoms() et terms() permettent d'étudier la structure du polynôme.
- Les objets Poly peuvent être additionnés, soustraits et multipliés.
- div() effectue une division polynomiale et retourne le quotient et le reste.
- eval(), diff() et all_roots() permettent respectivement d'évaluer, dériver et rechercher les racines d'un polynôme.
- La classe Poly prend également en charge les polynômes à plusieurs variables.
Le programme suivant rassemble plusieurs méthodes importantes de Poly afin d'analyser complètement un polynôme simple.
1 2 3 4 5 6 7 8 9 10 11 12 | from sympy import symbols, Poly, factor x = symbols("x") P = Poly(x**3 - 6*x**2 + 11*x - 6, x) print("Polynôme :", P.as_expr()) print("Degré :", P.degree()) print("Coefficient dominant :", P.LC()) print("Coefficients :", P.all_coeffs()) print("Termes :", P.terms()) print("Factorisation :", factor(P.as_expr())) print("Racines :", P.all_roots()) |
Sortie :
1 2 3 4 5 6 7 | Polynôme : x**3 - 6*x**2 + 11*x - 6 Degré : 3 Coefficient dominant : 1 Coefficients : [1, -6, 11, -6] Termes : [((3,), 1), ((2,), -6), ((1,), 11), ((0,), -6)] Factorisation : (x - 3)*(x - 2)*(x - 1) Racines : [1, 2, 3] |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
