Resolution d'une equation du second degré avec racines reelles et complexes en c

Soyez le premier à donner votre avis sur cette source.

Snippet vu 8 174 fois - Téléchargée 18 fois

Contenu du snippet

ce code resoud une equation du 1er et 2ème degré avec racine réelles et complexes et contrôle du saisie utilisateur
développé avec DEVC++.

Source / Exemple :


#include <stdio.h>
#include <math.h>
#include <string.h>
#include<stdlib.h>

/* Prototype des fonctrions*/
void rema(double *p);
void remb(double *y);
void remc(double *c);
void delta(double *a,double *b,double *c);

/* Fonction principale*/

int main(int argc, char* argv[])
{
	double w,r,t;	/* w r t respectivement font reference aux quofitients de l'equation A B C*/
bool var;var=true;
char re;		/* chaine de test de la volonté de l'utilisateur de resoudre une nouvelle equation*/ 		
bool val;val=false;

/*chaine de titrage */
printf("\n");printf("\n");
printf("\t************************************************************\n");
printf("\t************************************************************\n");

printf("\t        PROGRAMME DE RESOLUTION DES EQUATIONS DE    \n");
printf("\t       1er ET DEUXIEME DEGRE AVEC RACINES REELLES   \n");
printf("\t      ET COMPLEXES ET PRISE EN CHARGE DES CONTROLES  \n");
printf("\t                 DE SAISIE CHARACTERS \n");

printf("\t************************************************************\n");
printf("\t************************************************************\n");
printf("\n");

printf("\n");

while((var)&&(val==false))
{
rema(&w);
remb(&r);
remc(&t);
delta(&w,&r,&t); 

printf("\n\n\t autre equation O/N ?: \n");
scanf ("%s",&re);

if((re == 'o')||(re == 'O'))
{
var=true;
}
else
{
if((re=='n')||(re=='N'))
{
var=false;

}
else
{
printf("\n\n\t autre equation O/N ?: \n");  
scanf ("%s",&re);

while((re!='o')&&(re!='O')&&(re!='n')&&(re!='N'))
{
printf("\n\n\t autre equation O/N ?: \n");
scanf ("%s",&re);
if((re=='n')||(re=='N'))
{ 
	val=true;
}
}
}
}
}
	return 0;
}

void rema(double *p)/*procedure de remplissage de de A par passage par adresse*/
{
   	char buf[32];
	char bul[2]="0";
	bool var;
	var=true;
	
	printf("\t\nVeuillez entrer le coefficient de A S.V.P\n");
	scanf("%s",&buf);		/*lecture du variable en tant que chaine de caractere*/ 

  • p = atof(buf); /*fonction de conversion du caractere en float*/
while(var==true) { if (strcmp(buf, bul) == 0) /*comparaison du chaine avec la variable bul qui contient un zero de type char*/ { printf("\tvous avez taper un zero\n"); /* les chaines sont identiques */ printf("\t\nVeuillez entrer le coefficient de A different de zero\n"); scanf("%s",&buf);
  • p = atof(buf); /*fonction de conversion du caractere en float*/
var=true; /*variable booleene var fait que la boucle se repete tant que on donne une valeur de zero a A*/ } else { if (((strcmp(buf, bul) != 0))&&(*p==0)) /*vue que la conversion des chaines caracteres en float donne zero on associe ces deux conditions pour tomber sur le cas de saisie d'un caractere */ { printf("\tvous avez taper un caractere\n"); var=true; /* les chaines buf et bul sont différentes */ printf("\t\nVeuillez entrer le coefficient de A S.V.P\n"); scanf("%s",&buf);
  • p = atof(buf);
} else { printf("\t vous avez taper un nombre valide\n"); /* saisie d'un nombre valide*/ var=false; /*var permet à ce niveau de sortir de la boucle while*/ } } } } void remb(double *y) /*procedure de remplissage de B*/ { char buf[32] ,bul[2]="0"; /* meme logique que celle en dessus, sauf que la saisie d'un zero sera toleré*/ bool var; var=true; printf("\t\n Veuillez entrer le coefficient de B S.V.P\n"); scanf("%s",&buf);
  • y = atof(buf);
while(var==true) { if (strcmp(buf, bul) == 0) { printf("\tvous avez taper un zero\n"); /* les chaines sont identiques */ var=false; } else { if (((strcmp(buf, bul) != 0))&&(*y==0)) { printf("\tvous avez taper un caractere\n"); var=true;/* les chaines sont différentes */ printf("\t\nVeuillez entrer le coefficient de B S.V.P\n"); scanf("%s",&buf);
  • y = atof(buf);
} else { printf("\tvous avez taper un nombre valide\n"); var=false;}}} } void remc(double *z) /*procedure de remplissage de C*/ { char buf[32], bul[2]="0"; /* meme logique que celle de remplissage de B*/ bool var; var=true; printf("\t\nVeuillez entrer le coefficient de C S.V.P\n"); scanf("%s",&buf);
  • z = atof(buf);
while(var==true){ if (strcmp(buf, bul) == 0) { printf("\tvous avez taper un zero\n"); /* les chaines sont identiques */ var=false; } else { if (((strcmp(buf, bul) != 0))&&(*z==0)) { printf("\tvous avez taper un caractere\n"); var=true; /* les chaines sont différentes */ printf("\t\nVeuillez entrer le coefficient de C S.V.P\n"); scanf("%s",&buf);
  • z =atof(buf);
} else { printf("\tvous avez taper un nombre valide\n"); var=false;}}} } void delta(double *a,double *b,double *c) /* procedure delta pour calculer le delta et ces racines et leurs angles*/ { double delta,x0,x1,x2,u2,f1,f2; double tab1[2]; double tab2[2]; delta=((*b)*(*b))-(4*(*a)*(*c)); if(*b!=0) { if(delta==0) { x0=(-(*b))/(2*(*a)); printf("\n L'equation\n %6.2fx*x+%6.2lfx+%6.2f = 0 ",*a,*b,*c); printf("\n A UNE SEUL RACINE QUI EST %6.4f",x0); } else { if(delta<0) { delta=delta*(-1); /*delta multiplié par -1 pour pouvoir trouvé ces racines*/ tab1[1]=(-*b)/(2*(*a)); /*partie reele de x1*/ tab1[2]=(sqrt(delta))/(2*(*a)); /*partie imaginaire de x1*/ tab2[1]=(-*b)/(2*(*a)); /*partie reele de x2*/ tab2[2]=(-sqrt(delta))/(2*(*a));/*partie reele de x2*/ printf("\n L'equation\n %6.2fx2+%6.2fx+%6.2f = 0 ",*a,*b,*c); printf("\n A DEUX RACINES COMPLEXES QUI SONT %6.3f+%6.4fj avec PHI1=%3.0f et\n %6.3f%6.4fj avec PHI2=%3.0f ",tab1[1],tab1[2],floor((atan(tab1[2]/tab1[1]))*(180/3.14)),tab2[1],tab2[2],ceil((atan(tab2[2]/tab2[1]))*(180/3.14)));/*fonction predefinie atan(imaginaire/reele) retourne le resultat de PHI*/ } else { x1=(-(*b)+sqrt(delta))/(2*(*a)); /*racine reele de x1*/ x2=(-(*b)-sqrt(delta))/(2*(*a)); /*racine reele de x1*/ printf("\n L'equation\n %6.2fx2+%6.2fx+%6.2f = 0 ",*a,*b,*c); printf("\n A DEUX RACINES REELLES QUI SONT %6.4f et %6.4f",x1,x2); } } } else { if(((*c)!=0)&&(*b==0)){ /*cas ou on a un b=0 */ u2=-(*c)/(*a); if(u2>0){ f1=sqrt(u2); /* f1 racine reel*/ f2=-sqrt(u2); /* f2 racine reel*/ printf("\n L'equation\n %6.2fx*x + %6.2f =0 possede deux solutionx reelles %6.4f et %6.4f ",*a,*c,f1,f2); } else { u2=u2*(-1); f1=sqrt(u2); /* f1 reel*/ f2=-sqrt(u2); /* f2 imaginaire*/ printf("\n L'equation\n %6.2fx*x + %6.2fx =0 possede deux solutionx complexes %3.0fi et %3.0fi ",*a,*c,f1,f2); } } else { printf("\n L'equation\n %6.2fx*x + %fx + %f = 0 a pour solution 0",*a,*b,*c); /* cas ou a et b egals a zero*/ } } }

A voir également

Ajouter un commentaire

Commentaires

Messages postés
3
Date d'inscription
mardi 3 mars 2009
Statut
Membre
Dernière intervention
20 avril 2011

merci,puisque cette conversion *y=atof(buf) donne 0 dans les cas : buf='caractere' , buf='0' alors avec le test suivant "if (((strcmp(buf, bul) != 0))&&(*y==0)) : qui teste si buf est different du bul='0' et si *y==0" si cette condition est verifiée, on est alors sûre que buf='caractere', j'espere avoir bien répondu à ta question.
Messages postés
92
Date d'inscription
samedi 26 mars 2005
Statut
Membre
Dernière intervention
23 septembre 2015

Euh, je ne comprends pas ta raison ...
'if (*y == 0)' ou 'if (*y != 0)'
ça marche bien, généralement.
Messages postés
3
Date d'inscription
mardi 3 mars 2009
Statut
Membre
Dernière intervention
20 avril 2011

merci, c'est une meilleure façon de faire mais j'ai préféré la prémiére synthaxe puisqu'il me faut affecter une valeur à la variable buf pour qu'aprés le programme puisse differencier entre la saisie d'un zero et celle d'un caractére.
Messages postés
3813
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
12 juin 2020
107
Pourquoi faire un:

scanf("%s",buf);
*y = atof(buf);

au lieu de:

scanf("%l", y);

C'est super étrange !

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.