Résolution d'équations polynomiales du second degré à coefficients complexes

Soyez le premier à donner votre avis sur cette source.

Vue 6 278 fois - Téléchargée 218 fois

Télécharger le projet
Commenter

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...".

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).
Télécharger le projet

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Signaler
kenjimax
Messages postés
82
Date d'inscription
dimanche 3 août 2003
Statut
Membre
Dernière intervention
10 août 2007
:D

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 )
Signaler
hbpo
Messages postés
3
Date d'inscription
vendredi 18 juin 2004
Statut
Membre
Dernière intervention
17 novembre 2005
Les fractions j'y ai pensé c'est pas très dur à faire, ce qui m'embête c'est les irrationnels (racine de 2 par exemple) je ne sais pas déterminer si un nombre l'est ou pas...
S'inscrire maintenant

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.