Résolution d'équations polynomiales du second degré à coefficients complexes
Soyez le premier à donner votre avis sur cette source.
Vue 6 542 fois - Téléchargée 224 fois
Description
Encore une résolution d'équations du second degré mais cette fois ci avec des coefficients complexes.
C'est mon premier programme en c++, dites moi si j'utilise des fonctions spécifiques à windows ou d'autres trucs empechant l'exportation vers d'autres systemes d'exploitations.
Merci de ne pas mettre de commentaires du genre " encore un programme de resolution...".
Compile sous dev.
Pas de bugs à part qu'il faut rentrer un flottant quand on le demande, je ne sais pas encore comment gerer ça autrement...
J'ai fait beaucoup de tests de résultats en comparant avec une ti89 tous les résultats sont tombés justes (mais non calculés de maniere formelle), il se peut que j'en ai oublié et que certains résultats soient faux (je vais approfondir).
C'est mon premier programme en c++, dites moi si j'utilise des fonctions spécifiques à windows ou d'autres trucs empechant l'exportation vers d'autres systemes d'exploitations.
Merci de ne pas mettre de commentaires du genre " encore un programme de resolution...".
Source / Exemple :
#include <iostream>
#include <math.h>
using namespace std;
class Comp // Classe representant un nombre complexe
{
public:
float PartRe; // partie reelle du nombre
float PartIm; // partie imaginaire du nombre
float RacRe; // partie reelle des racines du nombre
float RacIm; // partie imaginaire d'une racine du nombre, la deuxieme n'etant pas utile
void RacineComplexe(); // calcule une racine du nombre
void AfficheComp(); // declaration de la fonction affichant un complexe
};
class Equa // Classe representant une equation
{
public:
Comp ParA; // premier parametre du polynome
Comp ParB; // deuxieme parametre du polynome
Comp ParC; // troisieme parametre du polynome
Comp Rac1; // premiere racine de l'equation
Comp Rac2; // seconde racine de léequation
Comp Det; // determinant du polynome
void Determinant(); // declaration de la fonction calculant le determinant
void Racines(); // declaration de la fonction calculant les racines
void Polynome(); // declaration de la fonction demandant le polynome a l'utilisateur
void AfficheEqua(); // declaration de la fonction affichant une equation
void AfficheResult();; // declaration de la fonction affichant l'equation et les racines
};
void Comp::RacineComplexe() // calcule la racine d'un nombre complexe
{
float a=sqrt(PartRe*PartRe+PartIm*PartIm);
if (PartIm<=0)
{
RacRe=sqrt(0.5*(PartRe+a));
RacIm=-sqrt(0.5*(a-PartRe));
}
else
{
RacRe=sqrt(0.5*(PartRe+a));
RacIm=sqrt(0.5*(a-PartRe));
}
}
void Equa::Polynome() // corps de la fonction polynome
{
cout << "Type (ReA+i*ImA)*x^2+(Reb+i*ImB)*x+(ReC+i*ImC)=0\n\n";
ParA.PartRe=0; ParA.PartIm=0;
while (ParA.PartRe==0 && ParA.PartIm==0)
{
cout << "Entrez ReA et ImA l'un au moins different de zero.\n";
cout << "ReA?\n";
cin >> ParA.PartRe;
cout << "ImA?\n";
cin >> ParA.PartIm;
}
cout << "\nReB?\n";
cin >> ParB.PartRe;
cout << "ImB?\n";
cin >> ParB.PartIm;
cout << "\nReC\n";
cin >> ParC.PartRe;
cout << "ImC\n\n";
cin >> ParC.PartIm;
}
Comp AddComp(Comp Nomb1,Comp Nomb2) // ajoute deux complexes
{
Comp Add;
Add.PartRe=Nomb1.PartRe+Nomb2.PartRe;
Add.PartIm=Nomb1.PartIm+Nomb2.PartIm;
Add.RacineComplexe();
return Add;
}
Comp MultComp(Comp Nomb1, Comp Nomb2) // multiplie deux complexes
{
Comp Mult;
Mult.PartRe=(Nomb1.PartRe*Nomb2.PartRe)-(Nomb1.PartIm*Nomb2.PartIm);
Mult.PartIm=(Nomb1.PartRe*Nomb2.PartIm)+(Nomb1.PartIm*Nomb2.PartRe);
Mult.RacineComplexe();
return Mult;
}
Comp OppComp(Comp a) // renvoie l'opposé d'un complexe
{
Comp b;
b.PartRe=-a.PartRe;
b.PartIm=-a.PartIm;
b.RacineComplexe();
return b;
}
bool EstCompNul(Comp a) // si un complexe est egal a zero ou non
{
return (a.PartRe==0 && a.PartIm==0);
}
Comp InvComp(Comp a) // renvoie l'inverse un complexe
{
if (EstCompNul(a))
{
cout << "Erreur : complexe nul";
Comp b;
b.PartRe=0;
b.PartIm=0;
b.RacineComplexe();
return b;
}
else
{
Comp b;
b.PartRe=a.PartRe/(a.PartRe*a.PartRe+a.PartIm*a.PartIm);
b.PartIm=-a.PartIm/(a.PartRe*a.PartRe+a.PartIm*a.PartIm);
b.RacineComplexe();
return b;
}
}
Comp ScalComp(Comp Nb1, float Scal) // renvoie le multiple d'un complexe par un scalaire
{
Comp Nb2;
Nb2.PartRe=Scal*Nb1.PartRe;
Nb2.PartIm=Scal*Nb1.PartIm;
Nb2.RacineComplexe();
return Nb2;
}
void Equa::Determinant() // Calcule le determinant det=b^2-4ac
{
Det=AddComp(MultComp(ParB,ParB),ScalComp(MultComp(ParA,ParC),-4));
Det.RacineComplexe();
}
void Equa::Racines() // determine la fonction qui va calculer les racines
{
Determinant();
Comp a;
a.PartRe=Det.RacRe;
a.PartIm=Det.RacIm;
Rac1=MultComp(AddComp(OppComp(ParB),a),InvComp(ScalComp(ParA,2)));
Rac2=MultComp(AddComp(OppComp(ParB),OppComp(a)),InvComp(ScalComp(ParA,2)));
}
void Comp::AfficheComp() // affiche un complexe
{
if ((PartRe==0) && (PartIm!=0))
{
cout << "(" << PartIm << "*i)";
}
else
{
if ((PartIm==0) && (PartRe!=0))
{
cout << PartRe;
}
else
{
if ((PartIm==0) && (PartRe==0))
{
cout << "0";
}
else
{
cout << "(" << PartRe << " + " << PartIm << "*i" << ") ";
}
}
}
}
void Equa::AfficheEqua()
{
ParA.AfficheComp();
cout << "*x^2 ";
if (EstCompNul(ParB) && !(EstCompNul(ParC)))
{
cout << "+ ";
ParC.AfficheComp();
}
else
{
if (EstCompNul(ParC) && !(EstCompNul(ParB)))
{
cout << "+ ";
ParB.AfficheComp();
cout << "*x ";
}
else
{
if (!(EstCompNul(ParB)) && !(EstCompNul(ParC)))
{
cout << "+ ";
ParB.AfficheComp();
cout << "*x + ";
ParC.AfficheComp();
}
}
}
cout << " =0";
};
void Equa::AfficheResult()
{
AfficheEqua();
cout << "\n\n";
if (EstCompNul(Det))
{
cout << "une seule racine : rac= " ;
Rac1.AfficheComp();
}
else
{
cout << "deux racines : rac1= " ;
Rac1.AfficheComp() ;
cout << " rac2= " ;
Rac2.AfficheComp();
}
cout << "\n\n";
}
int main()
{
char test=1;
while (test!='0')
{
Equa Poly;
cout << "Resolution d'equations de deuxieme degre a coefficients complexes.\n\n\n\n";
Poly.Polynome();
Poly.Racines();
Poly.AfficheResult();
cout << "0 pour quitter ou n'importe quel autre caractere pour une nouvelle equation.";
cin >> test;
}
return 0;
}
Conclusion :
Compile sous dev.
Pas de bugs à part qu'il faut rentrer un flottant quand on le demande, je ne sais pas encore comment gerer ça autrement...
J'ai fait beaucoup de tests de résultats en comparant avec une ti89 tous les résultats sont tombés justes (mais non calculés de maniere formelle), il se peut que j'en ai oublié et que certains résultats soient faux (je vais approfondir).
Codes Sources
A voir également
- équation du second degré à coefficients complexes
- Equation second degré coefficient complexe - Meilleures réponses
- Algorithme résolution équation second degré complexe - Meilleures réponses
- Delphi / Pascal : Resolution d'equation du second degre a coefficients complexes et(ou) reels - Code - Guide
- Résolution d'équation de 3 éme degré avec la méthode de newton - Codes sources - Visual Basic / VB.NET (Maths)
- C / C++ / C++.NET : Resolution d'equations (jusqu'au 3eme degre) + classe pour manipuler les nombre - Guide
- C / C++ / C++.NET : Résolution automatique des trinomes du second dégré. - Co - Guide
- Javascript : Résolveur d'equation (système, du second degré) + calculateur de c - Guide
Commentaires
En tout cas, on peut dire que les equations ca te passionne !
Mis a part ca, je trouve que ton code est assez clair ! Moi ca me plait bien ! Par contre, tu pourrais essayer mais c'est plus difficile, de faire un programme qui sorte des fractions en lieu et place des resultats avec restes. Avec par exemple, un affichage en opengl ou une autre librairie graphique.
Tu peux aussi, essayer de "coupler" tes programmes, faire un programme qui resolve tout en quelque sorte, avec un systeme d'heritage polymorphé(je mets le mot juste pour faire beau :D )
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.