Calcul de polynômes du second degré avec ses variations sur r.

Soyez le premier à donner votre avis sur cette source.

Snippet vu 4 841 fois - Téléchargée 29 fois

Contenu du snippet

Ce code source serv à calculer les racines des polynômes du second degré de la forme (ax²+bx+c) et à étudier le signe de votre fonction sur R.

Source / Exemple :


#include <iostream.h>
#include <math.h>
int main()
{
	int a; //Déclaration de trois variables a b et c
	int b;
	int c;
	int delta;  //Déclaration de la variable pour le discriminent (delta)
cout << "Votre polynome du second est sous la forme ax2+bx+c (2=carre).\n";
cout << "Entrez a=";
cin >> a;
cout << "Entrez b=";
cin >> b;
cout << "Entrez c=";
cin >> c;

delta=b*b-4*a*c; //Calcul de delta 

cout << "Votre discriminent delta est:" << delta << endl;

if (delta<0) //Si delta <0
{
	cout << "Votre polynome du second n'a pas de solution.\n\n";
	cout << "On note f(x)="<<a<<"x(carre)+"<<b<<"x+"<<c<<endl<<endl;
	if (a<0)
	{
	cout << "x     |-infini                                  +infini\n";
	cout << "-----------------------------------------------\n";
                cout << "f(x) |                         -                         \n\n";
	}
	if (a>0)
	{
	cout << "x     |-infini                                  +infini\n";
	cout << "-----------------------------------------------\n";
                cout << "f(x)  |                         +                       \n\n";
	}
}
if (delta>0)  //Si delta >0
{   
	cout << "Delta est superieur a 0 donc votre polynome du second " 
		 << "degre a deux racines distincts X1 et X2.\n\n"; 
	float rdelta =sqrt (delta); //Calcul de racine carré de delta
	float x1;
	float x2;
	x1=(-b-rdelta)/(2*a); //Calcul de X1
	x2=(-b+rdelta)/(2*a); //Calcul de X2

	cout << "X1 = "<< x1 <<endl;
    cout << "X2 = "<< x2 <<endl;
	cout << "On note f(x)="<<a<<"x(carre)+"<<b<<"x+"<<c<<endl<<endl;
	if (a>0)
	{
	cout << "x     |-infini       "<<x1<<"          "<<x2<<"    +infini\n";
	cout << "----------------------------------------------------\n";
                cout << "f(x) |         +     0    -     0           +                    \n\n";
    }
    if (a<0)
	{
	cout << "x     |-infinie      "<<x1<<"          "<<x2<<"    +infini\n";
	cout << "----------------------------------------------------\n";
                cout << "f(x) |         -     0    +     0           -                      \n\n";
    }

}
if (delta==0)
{
    float x0;
	cout << "Delta est egal a 0 donc votre polynome du second a une racine double X0.\n\n";
	x0=-b/(2*a); //Calcul de X0

    cout << "X0 = "<< x0 <<endl;
	cout << "On note f(x)="<<a<<"x(carre)+"<<b<<"x+"<<c<<endl<<endl;
	if (a>0)
	{
	cout << "x     |-infini            "<<x0<<"             +infini\n";
	cout << "-----------------------------------------------\n";
                cout << "f(x) |         +          0       +                    \n\n";
    }
    if (a<0)
	{
	cout << "x     |-infini            "<<x0<<"             +infini\n";
	cout << "------------------------------------------------\n";
                cout << "f(x) |         -          0        -                     \n\n";
    }
}

return main();
}

A voir également

Ajouter un commentaire

Commentaires

Messages postés
6535
Date d'inscription
lundi 16 décembre 2002
Statut
Modérateur
Dernière intervention
22 août 2010
7
Au temps pour moi il s'agit bien d'homomorphismes
Messages postés
6535
Date d'inscription
lundi 16 décembre 2002
Statut
Modérateur
Dernière intervention
22 août 2010
7
Tu es bien gentil Ratio mais le but de ce programme était il me semble d'étudier une fonction ploynomiale sur R et donc les racines complexes ne nous interressent pas ici. Par ailleurs je me demande pourquoi du parles de "homomorphisemes" (homéomorphismes?)
Messages postés
2
Date d'inscription
vendredi 26 décembre 2003
Statut
Membre
Dernière intervention
26 décembre 2003

J'ai fait une petite erreur dans la démonstration, que vous voudrez bien corriger vous-même :

J'ai écrit :

(x + b/2a)² - b²/4a² + c/a = 0, puis tout au même dénominateur :
(x + b/2a)² - (b² + 4ac)/4a² 0. Posons D le discriminant, défini par D b² - 4ac. On a donc :

Ce n'est pas b² + 4ac, mais b² - 4ac !

A bientôt
Messages postés
2
Date d'inscription
vendredi 26 décembre 2003
Statut
Membre
Dernière intervention
26 décembre 2003

Démonstration : Deux racines dans C pour ax² + bx + c

Soit le trinôme ax² + bx + c = 0
Factorisons par a : a(x² + bx/a + c/a) = 0 (a différent de 0, il ne nous intéresse pas)

donc x² + bx/a + c/a = 0.
Utilisons la forme canonique (a + b)² = a² + 2ab + b².
Ici, x² + bx/a ressemble fort à a² + 2ab, et (x + b/2a)² x² + 2bx/2a + b²/(2a)² x² + bx/a + b²/4a²
Le début de l'expression correspond, sauf le dernier terme. Ecrivons donc :

(x + b/2a)² - b²/4a² + c/a = 0, puis tout au même dénominateur :
(x + b/2a)² - (b² + 4ac)/4a² 0. Posons D le discriminant, défini par D b² - 4ac. On a donc :

(x + b/2a)² - D/4a² = 0

Avec ce résultat important, on a trois cas :

--------------------------------------------------------------------
1. D > 0. On peut alors écrire (j'appelle Sqr la racine carrée) :

(x + b/2a)² - D/4a² = (x + b/2a)² - (Sqr(D)/2a)²
C'est une identité remarquable du type a² - b² = (a + b)(a - b), d'où la factorisation :

[(x + b/2a) + Sqr(D)/2a][(x + b/2a) - Sqr(D)/2a] = 0
[ a + b ][ a - b ] = 0
On met tout au même dénominateur :
[x+ (b + Sqr(D))/2a][x + (b - Sqr(D))/2a] = 0

Les racines :

x' = (- b - Sqr(D))/2a
x'' = (- b + Sqr(D))/2a

--------------------------------------------------------------------
2. D = 0 On a donc :

(x + b/2a)² - D/4a² = (x + b/2a)²

La racine double est évidente, c'est -b/2a

--------------------------------------------------------------------
3. D < 0. Dans ce cas, et c'est le seul qui nous intéresse vraiment, D est négatif, donc - D est positif.

Dans C l'ensemble des complexes, on désigne i le nombre imaginaire tel que i² -1 (les homomorphismes, je n'en parle pas, c'est trop compliqué) et x se remplace par z (qui s'appelle l'affixe, défini par z x + iy).

(z + b/2a)² - D/4a² = (z + b/2a)² - (Sqr(-D)i)/2a)²

car (Sqr(-D)i)² Sqr(-D)² i² -(-D) = D

On réutilise les identités remarquables comme tout à l'heure, et :


(z + b/2a)² - (Sqr(-D)i)/2a)²
= [(z + b/2a) + (Sqr(-D)i)/2a][(z + b/2a) - (Sqr(-D)i)/2a]
= [z + (b + Sqr(-D)i)/2a][z + (b - Sqr(-D)i)/2a]

Deux racines :

x' = (- b - Sqr(-D)i)/2a

x'' = (- b + Sqr(-D)i)/2a

où, je le rappelle, -D > 0 car D < 0. Pour ceux qui préfèrent, écrivez en valeur absolue : Sqr( |D| )

Voilà tout. En fait, il y a deux racines dont les formules sont sensiblement les mêmes que pour D > 0. Dans le programme, il suffit de calculer, lorsque D < 0, les résultats pour |D|, et faire afficher dans ce résultat un i. Rien de bien compliqué en fait (et je crois même qu'on puisse directement calculer dans
C. N'y a-t-il pas une bibliothèque prévue à cet effet ?).
Messages postés
5
Date d'inscription
dimanche 21 décembre 2003
Statut
Membre
Dernière intervention
25 juillet 2006

il est bien ton programme

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.