Résolution des équations du 4ème degré
Description
Le code a pour objet la résolution des équations du quatrième degré de la forme :
a4 x^4 + a3 x^3 + a2 x^2 + a1 x + a0 = 0
La méthode choisie est assez originale, puisqu'elle fait appel aux trigonoméries rectiligne et hyperbolique et à la représentation complexe des racines.
Après saisie dans une fenêtre de la valeur des 4 coefficients a4, a3, a2, a1, a0 le code calcule les 4 racines complexes x1, x2, x3, x4
Les résultats apparaissent dans la même fenêtre ainsi que dans un plan tel que : abcisse = partie réelle et ordonnée = partie imaginaire.
Ce code devrait intéresser les débutants qui cherchent à utiliser l'interface graphique Tkinter ainsi que ceux confrontés à ce classique en math.
Sur la méthode de calcul elle-même, je n'ai pas trouvé d'exposé clair dans la "littérature" qui traite de façon exhaustive tous les cas particuliers.
Aussi j'invite les fanas à consulter le menu "PRESENTATION" du code, pour voir comment j'ai apporté ma solution.
Commentaires et cotations seront les bienvenus !
a4 x^4 + a3 x^3 + a2 x^2 + a1 x + a0 = 0
La méthode choisie est assez originale, puisqu'elle fait appel aux trigonoméries rectiligne et hyperbolique et à la représentation complexe des racines.
Après saisie dans une fenêtre de la valeur des 4 coefficients a4, a3, a2, a1, a0 le code calcule les 4 racines complexes x1, x2, x3, x4
Les résultats apparaissent dans la même fenêtre ainsi que dans un plan tel que : abcisse = partie réelle et ordonnée = partie imaginaire.
Source / Exemple :
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# Résolution des équations du quatrième degré
# de la forme
# a4 x^4 + a3 x^3 + a2 x^2 + a1 x + a0 = 0
#_________________________________________________________________________________________________________________________________________________________________________
from Tkinter import *
from math import *
from cmath import*
from tkMessageBox import askokcancel
#_________________________________________________________________________________________________________________________________________________________________________
def resoudre_4_degre():
global A3,A2,A1,A0
# global b,c,d,e
# considérons l'équation générale du quatrième degré :
# a4 x^4 + a3 x^3 + a2 x^2 + a1 x + a0 = 0 (1)
# entrée des coefficients a4 , a3 , a2 , a1 , a0
a4,a3,a2,a1,a0 = float(entr4.get()),float(entr3.get()),float(entr2.get()),float(entr1.get()),float(entr0.get())
# transformation de l'équation :
# x^4 + b x^3 + c x^2 + d x + e = 0 (2)
# avec les coefficients :
b ,c ,d ,e = a3/a4 ,a2/a4 ,a1/a4 ,a0/a4
# après le changement de variable : x = X - b/4
# l'équation (2) devient :
# X^4 + p X^2 + q X + r = 0 (3)
# avec les coefficients :
p ,q ,r = c-3./8*b**2 ,d-b*c/2+b**3/8 ,e-b*d/4+c*b**2/16-3./256*b**4
# étudions l'expression suivante :
# X^4 + y X^2 + y^2/4
# soit :
# ( X^2 + y/2 )^2 = -p X^2 - q X - r + y X^2 + y^2/4
# ( X^2 + y/2 )^2 = ( y - p ) X^2 - q X + y^2/4 - r
# son second membre est un carré parfait si le discriminant de l'équation du second degré en X est nul :
# q^2 - 4 (y - p ) ( y^2 /4 - r ) = 0
# y^3 -p y^2 - 4 r y + 4 p r - q^2 = 0
# considérons maintenant l'équation suivante :
# A3 y^3 + A2 y^2 + A1 y + A0 = 0
# avec les coefficients :
A3 ,A2 ,A1 ,A0 = 1,-p ,-4*r ,4*p*r-q**2
# et recherchons une racine réelle y1 :
resoudre_3_degre()
if y1==p:
X1,X2,X3,X4=sqrt(-p/2+1./2*sqrt(p**2-4*r)),sqrt(-p/2-1./2*sqrt(p**2-4*r)),-sqrt(-p/2+1./2*sqrt(p**2-4*r)),-sqrt(-p/2-1./2*sqrt(p**2-4*r))
else:
y0=y1
# Discriminant D12
D12=-y0-p+2*q/sqrt(y0-p)
# Discriminant D34
D34=-y0-p-2*q/sqrt(y0-p)
# calcul des quatre racines complexes de l'équation : X1, X2, X3, X4
X1,X2,X3,X4=1./2*(-sqrt(y0-p)+sqrt(D12)),1./2*(-sqrt(y0-p)-sqrt(D12)),1./2*(sqrt(y0-p)+sqrt(D34)),1./2*(sqrt(y0-p)-sqrt(D34))
# calcul des quatre racines complexes de l'équation : x1, x2, x3, x4
x1,x2,x3,x4=X1-b/4,X2-b/4,X3-b/4,X4-b/4
# isolation des parties réelles et imaginaires des quatre racines x1, x2, x3, x4
xr1,xi1=x1.real,x1.imag
xr2,xi2=x2.real,x2.imag
xr3,xi3=x3.real,x3.imag
xr4,xi4=x4.real,x4.imag
# affichage des parties réelles et imaginaires avec trois décimales
x1,x2,x3,x4=complex(round(xr1,3),round(xi1,3)),complex(round(xr2,3),round(xi2,3)),complex(round(xr3,3),round(xi3,3)),complex(round(xr4,3),round(xi4,3))
# affichage des quatre racines dans le plan complexe de la fenêtre
can.coords(c1,L/2+50*xr1-R,L/2-50*xi1-R,L/2+50*xr1+R,L/2-50*xi1+R)
can.coords(c2,L/2+50*xr2-R,L/2-50*xi2-R,L/2+50*xr2+R,L/2-50*xi2+R)
can.coords(c3,L/2+50*xr3-R,L/2-50*xi3-R,L/2+50*xr3+R,L/2-50*xi3+R)
can.coords(c4,L/2+50*xr4-R,L/2-50*xi4-R,L/2+50*xr4+R,L/2-50*xi4+R)
# affichage de leur légende dans le plan complexe de la fenêtre
can.coords(txt_x1,L/2+50*xr1+15,L/2-50*xi1)
can.coords(txt_x2,L/2+50*xr2,L/2-50*xi2-15)
can.coords(txt_x3,L/2+50*xr3,L/2-50*xi3+15)
can.coords(txt_x4,L/2+50*xr4-15,L/2-50*xi4)
txta.configure(text = "" + str(a4))
txtb.configure(text = "" + str(a3))
txtc.configure(text = "" + str(a2))
txtd.configure(text = "" + str(a1))
txte.configure(text = "" + str(a0))
text_x1.configure(text = "" + str(x1))
text_x2.configure(text = "" + str(x2))
text_x3.configure(text = "" + str(x3))
text_x4.configure(text = "" + str(x4))
#_________________________________________________________________________________________________________________________________________________________________________
def resoudre_3_degre():
global y1,y2,y3
# considérons l'équation générale du troisième degré :
# A3 y^3 + A2 y^2 + A1 y + A0 = 0 (1)
# soit encore :
# A y^3 + B y^2 + C y + D = 0 (2)
# avec :
B,C,D=A2/A3,A1/A3,A0/A3
# après le changement de variable y = Y - B/3
# et en posant :
P,Q=C/3-B*B/9,B*B*B/27-B*C/6+D/2
# l'équation (2) devient :
# Y^3 + 3PY + 2Q = 0
# calcul du discriminant
Discriminant=P**3+Q**2
# calcul de s = (signe de Q) x sqrt(valeur absolue de P)
if P<>0:s=Q/fabs(Q)*sqrt(fabs(P))
# calcul des trois racines complexes de l'équation : Y1, Y2, Y3
if P<0:
if Discriminant<=0:
f=acos(Q/(s**3))
Y1=complex(-2*s*cos(f/3))
Y2=complex(2*s*cos(60*pi/180-f/3))
Y3=complex(2*s*cos(60*pi/180+f/3))
if Discriminant>0:
fc=acosh(Q/(s**3))
Y1=complex(-2*s*cosh(fc/3))
Y2=complex(s*cosh(fc/3),sqrt(3)*s*sinh(fc/3))
Y3=complex(s*cosh(fc/3),-sqrt(3)*s*sinh(fc/3))
if P>0:
fs=asinh(Q/(s**3))
Y1=complex(-2*s*sinh(fs/3))
Y2=complex(s*sinh(fs/3),sqrt(3)*s*cosh(fs/3))
Y3=complex(s*sinh(fs/3),-sqrt(3)*s*cosh(fs/3))
if P==0:
if Q>0:Y1=Y2=Y3=complex(pow(2*Q,1./3))
if Q<0:Y1=Y2=Y3=complex(pow(-2*Q,1./3))
if Q==0:Y1=Y2=Y3=complex(0)
# calcul des trois racines complexes de l'équation : y1, y2, y3
y1,y2,y3=Y1-A2/(3*A3),Y2-A2/(3*A3),Y3-A2/(3*A3)
#_________________________________________________________________________________________________________________________________________________________________________
def presentation():
"Fenêtre-message contenant la description sommaire de la méthode de calcul"
msg =Toplevel()
Message(msg, bg ="dark green", fg ="white", width =810,font ="Arial 9",
text =''' Méthode de calcul\n
La méthode choisie est assez originale, puisqu'elle fait appel aux trigonoméries rectiligne et hyperbolique et à la représentation complexe des racines.
Le code a pour objet la résolution des équations du quatrième degré de la forme :
a4 x^4 + a3 x^3 + a2 x^2 + a1 x + a0 = 0 (1)
Nota : pour résoudre les équations de degré inférieur, il suffit de choisir la valeur zéro pour les derniers coefficients :
- troisième degré : a0 = 0
- second degré : a1 , a0 = 0, 0
- premier degré : a2 , a1 , a0 = 0 , 0 , 0
et d'éliminer les racines nulles
Après avoir ramené l'équation (1) sous la forme suivante :
x^4 + b x^3 + c x^2 + d x + e = 0 (2)
avec les nouveaux coefficients :
b , c , d , e = a3 / a4 , a2 / a4 , a1 / a4 , a0 / a4
Aaprès le changement de variable : x = X - b/4
l'équation (2) devient :
X^4 + p X^2 + q X + r = 0 (3)
avec les coefficients :
p ,q ,r = c - 3./8 b^2 ,d - b c / 2 + b^3 / 8 ,e - b d / 4 + c b^2 / 16 - 3 / 256 b^4
Etudions maintenant l'expression suivante :
X^4 + y X^2 + y^2 / 4
Elle s'écrit aussi :
( X^2 + y/2 )^2 = - p X^2 - q X - r + y X^2 + y^2 / 4
( X^2 + y/2 )^2 = ( y - p ) X^2 - q X + y^2 / 4 - r
Son second membre est un carré parfait si le discriminant de l'équation du second degré en X est nul :
q^2 - 4 (y - p ) ( y^2 / 4 - r ) = 0
y^3 - p y^2 - 4 r y + 4 p r - q^2 = 0
Considérons alors l'équation suivante :
A3 y^3 + A2 y^2 + A1 y + A0 = 0 (3)
avec les coefficients :
A3 ,A2 ,A1 ,A0 = 1, -p , -4 r , 4 p r - q^2
et recherchons une racine réelle y1 de (3) :
L'équation (3) s'écrit :
y^3 + B y^2 + C y + D =0 (4)
avec les nouveaux coefficients :
B, C, D = A2 / A3, A1 / A3,A0 / A3
Après le changement de variable y = Y - B / 3
et en posant :
P , Q = C/3 - B^2 / 9, B^3 / 27 - B C / 6 + D / 2
l'équation (4) devient :
Y^3 + 3 P Y + 2 Q = 0 (5)
calcul du discriminant
Discriminant = P^3 + Q^2
on procède ensuite au calcul des trois racines complexes Y1, Y2, Y3 de l'équation (5)
puis à celui des trois racines complexes y1, y2, y3 de l'équation (4)
ce qui permet de déterminer la racine recherchée ci-dessus : y1
On revient alors au calcul de X en résolvant les équations du second degré suivantes :
( X^2 + y/2 )^2 = ( y1 - p ) ( X - q / 2 ( y1 - p ) )^2
X^2 +/- sqrt ( y1- p ) X -/+ q / 2 / sqrt ( y1 - p ) + y1 / 2 = 0
ce qui donne X1, X2, X3, X4 puis x1, x2, x3, x4''').pack(padx =10, pady =10)
#_________________________________________________________________________________________________________________________________________________________________________
def processus():
"Fenêtre-message contenant la description du processus"
msg =Toplevel()
Message(msg, bg ="dark green", fg ="white", width =500,font ="Arial 9",
text='''PROCESSUS à suivre\n
1. Entrer la valeur des 4 coefficients a4, a3, a2, a1, a0
Nota : lorsqu'un coefficient est nul, il est nécessaire d'entrer 0 dans le champ
2. Cliquer sur le bouton < Résoudre ! > :
3. Les 4 racines de l'équation apparaissent sous la forme suivante :
racine x = partie réelle + partie imaginaire x j
ainsi que dans le plan complexe :
parties réelles en abcisse
parties imaginaires en ordonnée
5. Cliquer sur < Quitter le jeu !> pour abandonner la partie\n''').pack(padx =10, pady =10)
#_________________________________________________________________________________________________________________________________________________________________________
def aPropos():
"Fenêtre-message indiquant les versions utilisées"
msg =Toplevel()
Message(msg, width =200, aspect =100, justify =CENTER,
text ='''Résolution des équations du quatrième degré
HCD, Novembre 2006
Python version 2.5
Tk version 8.4''').pack(padx =10, pady =10)
#_________________________________________________________________________________________________________________________________________________________________________
def quitter():
" pour quitter l'application "
ans=askokcancel('Résolution des équations du troisième degré',"Voulez-vous réellement quitter ?")
if ans:root.quit()
#_________________________________________________________________________________________________________________________________________________________________________
def makemenu(win):
"barre de menu"
top=Menu(win)
win.config(menu=top)
R=Menu(top)
top.add_cascade(label='Présentation',menu=R,underline=0)
R.add_command(label='Méthode de calcul',command=presentation,underline=0)
R.add_command(label='Processus',command=processus,underline=0)
R.add_command(label='A propos',command=aPropos,underline=0)
Q=Menu(top)
top.add_cascade(label='Quitter !',menu=Q,underline=0)
Q.add_command(label='Quitter le jeu !!',command=quitter,underline=0)
#_________________________________________________________________________________________________________________________________________________________________________
#Programme Principal
root = Tk()
root.title("Résolution des équations du quatrième degré")
root.geometry('800x800')
L=500
R=8
makemenu(root)
#_________________________________________________________________________________________________________________________________________________________________________
can=Canvas(root,bg='dark green',height=L,width=L)
can.grid(row=10,column=0)
can.create_line(0,L/2,L,L/2,fill='orange')
can.create_line(L/2,0,L/2,L,fill='orange')
c1=can.create_oval(0,0,0,0,fill='red',width=1)
c2=can.create_oval(0,0,0,0,fill='red',width=1)
c3=can.create_oval(0,0,0,0,fill='red',width=1)
c4=can.create_oval(0,0,0,0,fill='red',width=1)
(Label(root, text = "Equation du quatrième degré dont on cherche les racines x1,x2,x3,x4 dans le plan complexe :\na4 x^4 + a3 x^3 + a2 x^2 + a1 x + a0 = 0\nx1,2,3,4= (partie réelle de x1,2,3,4 + partie imaginaire de x1,2,3,4 x j)")).grid(row=0, column=0)
#Entrées
entr4 = Entry(root)
entr4.grid(row=1, column =1)
entr3 = Entry(root)
entr3.grid(row=2, column =1)
entr2 = Entry(root)
entr2.grid(row=3, column =1)
entr1 = Entry(root)
entr1.grid(row=4, column =1)
entr0 = Entry(root)
entr0.grid(row=5, column =1)
(Label(root, text = "entrée du coefficient a4 =")).grid(row=1, column=0,sticky=E)
txta = Label(root)
(Label(root, text = "entrée du coefficient a3 =")).grid(row=2, column=0,sticky=E)
txtb = Label(root)
(Label(root, text = "entrée du coefficient a2 =")).grid(row=3, column=0,sticky=E)
txtc = Label(root)
(Label(root, text = "entrée du coefficient a1 =")).grid(row=4, column=0,sticky=E)
txtd = Label(root)
(Label(root, text = "entrée du coefficient a0 =")).grid(row=5, column=0,sticky=E)
txte = Label(root)
(Label(root, text = "racine x1 =")).grid(row=6, column=0,sticky=E)
text_x1 = Label(root)
text_x1.grid(row=6, column =1)
(Label(root, text = "racine x2 =")).grid(row=7, column=0,sticky=E)
text_x2 = Label(root)
text_x2.grid(row=7, column =1)
(Label(root, text = "racine x3 =")).grid(row=8, column=0,sticky=E)
text_x3 = Label(root)
text_x3.grid(row=8, column =1)
(Label(root, text = "racine x4 =")).grid(row=9, column=0,sticky=E)
text_x4 = Label(root)
text_x4.grid(row=9, column =1)
can.create_text(L-30,L/2-10,text='axe réel',fill="white")
can.create_text(L/2+40,10,text='axe imaginaire',fill="white")
can.create_text(L-10,L/2+10,text='5',fill="white")
can.create_text(10,L/2+10,text='-5',fill="white")
can.create_text(L/2-10,L/2+10,text='0',fill="white")
can.create_text(L/2-10,10,text='5',fill="white")
can.create_text(L/2-10,L-10,text='-5',fill="white")
txt_x1=can.create_text(-10,0,text='x1',fill="yellow")
txt_x2=can.create_text(-10,0,text='x2',fill="yellow")
txt_x3=can.create_text(-10,0,text='x3',fill="yellow")
txt_x4=can.create_text(-10,0,text='x4',fill="yellow")
button = Button(root, text='Résoudre !', command =resoudre_4_degre)
button.grid(row=6, column =0)
root.mainloop()
root.destroy()
Conclusion :
Ce code devrait intéresser les débutants qui cherchent à utiliser l'interface graphique Tkinter ainsi que ceux confrontés à ce classique en math.
Sur la méthode de calcul elle-même, je n'ai pas trouvé d'exposé clair dans la "littérature" qui traite de façon exhaustive tous les cas particuliers.
Aussi j'invite les fanas à consulter le menu "PRESENTATION" du code, pour voir comment j'ai apporté ma solution.
Commentaires et cotations seront les bienvenus !
Codes Sources
A voir également
- Résolution des équations du 4ème degré
- Degré pourcentage - Forum VB.NET
- Grp - groupe de résolution de problèmes - Forum PHP
- Overload resolution failed - Forum VB.NET
- Droitereg excel degré 2 ✓ - Forum VBA Office (Excel, Word ...)
- Problème de résolution - Forum Delphi / Pascal
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.