fonction racines équation du second degré

Question

Le problème

Ecrire une fonction qui calcule les racines réelles et imaginaires de l'équation quadratique

ax^2 +bx+c = 0 

Vous devez gérer les trois types de racines.

Astuce: utiliser ce prototype de fonction:

int calculateRoots(int a,int b,int c,float* root1,float* root2); 

Mes questions:

• comment une fonction de résolution des équations du second degré retourne un int? Je suis paumé sur ce que cela signifie
• J'ai changé le type de retour de auj à void() mais je ne pouvais pas gérer les 2 racines imaginaires ne sais pas comment retourner réel + imag i

Voici ce que je suis arrivé si loin:

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


void calculateRoots(int a,int b,int c,float* root1,float* root2); 
    int main() 
    { 
     float r1,r2; 
     int a,b,c; 
     printf("enter the coefficients :\n"); 
     scanf("%d%d%d",&a,&b,&c); 
      void calculateRoots(a,b,c,&r1,&r2); 
     printf("%d and %d are roots,r1,r2); 
     return 0; 
    } 
    void calculateRoots(int a,int b,int c,float* root1,float* root2) 
    { float x=b*b-4*a*c; 
     if(x==0) 
     { 
      *root1=(-1*b)/(2*a); 
      *root2=(-1*b)/(2*a); 
     } 
     else if(x>0) 
     { 
      *root1=(-1*b+x)/(2*a) ; 
      *root2=(-1*b-x)/(2*a) ; 
     } 
     if(x<0) 
     { 
      root1=// Any help here 
     } 
    } 

Answer 1

comment une fonction de résolution des équations du second degré retourne un int

Vous devez retourner le numéro des racines, de sorte que vous sachiez combien de racines à imprimer.

je ne pouvais pas gérer les 2 racines imaginaires ne savez pas comment revenir réel + imag

Je suppose (mais peut-être @deamentiaemundi est correct, parce que pour ce problème, vous avez vraiment seulement deux différents chiffres qui, avec l'aide de la valeur de retour de la fonction, permettent de reconstituer résultat valide, et après avoir lu votre question encore une fois, libellé peut suggérer), vous êtes censé utiliser deux réseaux d'éléments:

float resultRoot1[2]; 
float resultRoot2[2]; 
int numRoots = calculateRoots(a, b, c, resultRoot1, resultRoot2); 

intérieur calculateRoots

root1[0] = real_part; 
root1[1] = imaginary_part; 

Par exemple, étant donné

2x^2 + 2x + 1 = 0 

vous devez retourner

-0.5 - 0.5i 
-0.5 + 0.5i 

si resultRoot1 doit contenir des valeurs -0.5, -0.5 et resultRoot2 valeurs -0.5, 0.5.

---

Au-delà de votre asigment (pour des considérations futures) vous pouvez utiliser struct

struct ComplexNum 
{ 
    double re, im; 
}; 

int calculateRoots(int a, int b, int c, struct ComplexNum* root1, struct ComplexNum* root2) 
{ 
    ... 
    root1->re = real_part; 
    root1->im = imaginary_part; 
    ... 
    return num_roots; 
} 
... 
struct ComplexNum resultRoot1, resultRoot2; 
int numRoots = calculateRoots(a, b, c, &resultRoot1, &resultRoot2); 

ou mieux encore en-tête complexe

#include <complex.h> 

int calculateRoots(int a, int b, int c, double complex* root1, double complex* root2) 
{ 
    ... 
    *root1 = real_part + imaginary_part * I; 
    ... 
    return num_roots; 
} 
... 
double complex resultRoot1; 
double complex resultRoot2; 
int numRoots = calculateRoots(a, b, c, &resultRoot1, &resultRoot2); 

Answer 2

Une variante aux conseils de Daniel Sek:

Comme les règles de résolution des équations quadratiques (w.relfs réels) sont assez simples, vous pouvez utiliser les deux float arguments dans le prototype comme vous l'avez fait.

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

int calculateRoots(int a, int b, int c, float *root1, float *root2); 

int main(void) 
{ 
    float r1, r2; 
    int a, b, c; 
    int ret; 

    puts("enter the coefficients a, b, c:"); 
    ret = scanf("%d%d%d", &a, &b, &c); 
    // always, An I mean _always_ check the returns of scanf! 
    if(ret != 3){ 
    puts("No, the three coeficients, please, and they have to be integers. Try again."); 
    return EXIT_FAILURE; 
    } 

    ret = calculateRoots(a, b, c, &r1, &r2); 
    // the function returns a value that is eather the sign of the 
    // determinant or an error. 
    switch (ret) { 
    case 0: 
     printf("r1 = r2 = %f\n", r1); 
     break; 
    case 1: 
     printf("r1 = %f and r2 = %f\n", r1, r2); 
     break; 
    case -1: 
     printf("r1 = %f + %fi and r2 = %f - %fi\n", r1, r2, r1, r2); 
     break; 
    default: 
     puts("No roots found, check input"); 
     break; 
    } 
    return 0; 
} 

int calculateRoots(int a, int b, int c, float *root1, float *root2) 
{ 
    float x; 
    // shortcut: check for a== 0 
    if (a == 0) { 
    return -2; 
    } 
    // find determinant 
    x = b * b - 4 * a * c; 
    fprintf(stderr, "determinant is: %f\n",x); 
    // checking if a float is exactly equal to a number is highly problematic! 
    if (x == 0.0) { 
    *root1 = (-1 * b)/(2 * a); 
    *root2 = *root1; 
    return 0; 
    } 
    // macro avaliable with c >= c99 
    else if (isgreater (x , 0.0)) { 
    *root1 = (-b + sqrt(x))/(2 * a); 
    *root2 = (-b - sqrt(x))/(2 * a); 
    return 1; 
    } 
    // macro avaliable with c >= c99 
    if (isless(x , 0.0)) { 
    // not the nicest way possible, but good enough if documented: 
    // put the real part in one variable, the imaginary part in another, 
    // return the sign and let the caller sort it out. 
    *root1 = -b/(2 * a); 
    *root2 = sqrt(-x)/(2 * a); 
    return -1; 
    } 
    // notreached 
    return -3; 
} 

C99 et a plus tard des nombres complexes. Vous pourriez les utiliser à la place.