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

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

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.