Algorithme racine

[221]

bonjour a tous,
je débute en programmation ,j ai essayé de transcrire l'algorithme de dichotomie en langage c et ca a donné le code suivant qui marche a peu prés, le problème c est qu il retourne la racine du polynôme seulement si elle est entier ou réel de virgule 0.5 (c est a dire que si la racine est entre 2 et 2.5 ou 2.5 et 3 le programme bug et ne retourne rien ) ,pourtant ma fonction racine retourne un double
merci

#include <stdio.h>
#include <math.h>
#define nmax 100
double fct_p(double x,int n,double poly[] )
{
   double result1 = 0;
       int i;
           for(i=n;i>=0;i--)
            {
              result1 = result1 * x + poly[i];
              }    
              return result1;
               }
               double rac(int A,int B, int n,double poly[nmax])
               {  
                   double C;  
                   while(A<B)  {
               C = (A+B)/2.0;
               if (fct_p(C, n, poly) == 0)
                {      
                    return C;
                 }
                  else if(fct_p(C, n, poly)*fct_p(A,n,poly)< 0)    {
                   B = C;
                    }
                     else
                      { A = C;
                      }
                      }
                       printf("la valeur introuvable");
                        return -1;
                        }
                        int main(int argc, char* argv[]) {
                         int n, i, A, B;
                           double poly[nmax];
                             char y ;
                             do  {
                            printf("Donnez le degre de votre polynome: ");
                            scanf(" %d", &n);    
                             
                            for(i=0; i<=n; i++)     {
                            printf("  _ Coefficient %d : ", i);
                            scanf(" %lg", &poly[i]);
                            }
                            printf("_Donnez la valeur de l'intervalle gauche : ");
                            scanf(" %d", &A);
                            printf("_Donnez la valeur de l'intervalle droit : ");
                            scanf(" %d", &B);
                            if(fct_p(A,n, poly) * fct_p(B, n, poly) > 0)     {
                            printf("ERREUR !!");     }
                            else     {
                            printf("_ La racine est : %lg\n", rac(A, B, n, poly));
                                    }    do
                                        {   printf("Voulez-vous refaire un autre calcul?? (Y/N):");
                                            scanf(" %c", &y);     }while(y != 'Y' && y != 'N');
                                                                }
                                            while( y== 'Y');
                                            printf("Merci, Au revoir !\n");
                                            return 0;
                                                        }

-----

[invite0bbe92c0]

Bonjour

Pour vous aider,il faudrait pouvoir lire le code; or , l'indentation utilisée rend cette tâche virtuellement impossible.
Reposter le code indenté proprement (c'est à dire en alignant les accolades ouvrantes sur la même colonne que les fermantes, et en décalant à chaque niveau - là je ne sais pas comment vous avez fait ce machin).

[imoca]

Bonjour,

Après une lecture en diagonale, le code semble réaffecter les valeurs A et B passer en paramètres de la fonction.
Pour corriger cela, crée dans la fonction rac, 2 variables (a et b) initialiser avec A et B, et remplace les A (resp. B) par a (resp. b).
Pour le test d’arrêt, utilise |C|<epsilon.

[221]

merci d avoir répondu
dsl pour la structure bordélique du programme bluedeep :

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

double fct_p(double x,int n,double poly[] )
    {
     double result1 = 0;
     int i;
     for(i=n;i>=0;i--)
       {
        result1 = result1 * x + poly[i];
       }
    return result1;
    }

    double rac(int A,int B, int n,double poly[nmax])
    {

     double C;
     while(A<B)
        {

        C = (A+B)/2.0;
        if (fct_p(C, n, poly) == 0)
            {
             return C;
            }

        else if(fct_p(C, n, poly)*fct_p(A,n,poly)< 0)
            {
             B = C;
            }

        else
            {
            A = C;
            }

        }

        printf("la valeur introuvable");
        return -1;
    }

        int main(int argc, char* argv[])
        {
         int n,i,A,B;
         double poly[100];
         char ms ;

           do  {
                printf("Donnez le degre de votre polynome: ");
                scanf(" %d", &n);
                for(i=0; i<=n; i++)
                    {
                       printf("  _ Coefficient %d : ", i);
                       scanf(" %lg", &poly[i]);
                    }

                    printf("_Donnez la valeur de l'intervalle gauche : ");
                    scanf(" %d", &A);
                    printf("_Donnez la valeur de l'intervalle droit : ");
                    scanf(" %d", &B);

                    if(fct_p(A,n, poly) * fct_p(B, n, poly) > 0)
                        {
                            printf("ERREUR !!");
                        }

                    else
                        {
                            printf("_ La racine est : %lg\n", rac(A, B, n, poly));
                        }

                    do
                        {
                            printf("Voulez-vous refaire un autre calcul?? (Y/N):");

                            scanf(" %c", &ms);

                        } while(ms != 'Y' && ms != 'N');


               } while( ms== 'Y');
                return 0;

        }

imoca j ai essayé comme t'as dit d'éviter la confusion en utilisant des variables locales a la fonction rac mais ca bloque tjr :

double rac(int a,int b, int n,double poly[nmax])
    {
     int a,b;
     double C;
     while(a<b)
        {

        C = (a+b)/2.0;
        if (fct_p(C, n, poly) == 0)
            {
             return C;
            }

        else if(fct_p(C, n, poly)*fct_p(a,n,poly)< 0)
            {
             b = C;
            }

        else
            {
            a = C;
            }

        }

        printf("la valeur introuvable");
        return -1;
    }

quand la racine est une valeur entière ou un réel a virgule 0.5(1.5,12.5,45.5......) ca marche ,mais entre deux le prog ne retourne rien

[A voir en vidéo sur Futura]

[Jack]

while(A<B)

Je ne comprends pas non plus ce test d'arrêt. Comment A pourrait-il devenir supérieur à B?
Tu devrais suivre le conseil d'imoca en passant la précision en paramètre de la fonction racine.

PS: c'est un peu mieux pour l'indentation mais on est encore loin de la perfection...

[221]

merci jack
j ai refait le test d arrêt de la fct racine en fixant une valeur epsilon directement dans la fonction :

double rac(int A,int B, int n,double po[])
    {

     double C;
     while(fabs(B-A)>0.0001)
        {

        C = (A+B)/2.0;
        if (fct_p(C, n, po) == 0)
            {
             return C;
            }

        else if(fct_p(C, n, po)*fct_p(A,n,po)< 0)
            {
             B = C;
            }

        else
            {
            A = C;
            }

        }

        printf("la valeur introuvable");
        return -1;
    }

j ai mis des variables locales pour les deux fonctions.
ca ne change tjr rien .

c est frustrant


ps: oui c est bien loin de la perfection mais avec un peu de perseverence ca deviendra lisible

[Jack]

Ce qui m'étonne dans ton code, c'est que A et B soient des entiers et C un double.

Du coup pour la condition terminale, ça se présente mal: while(fabs(B-A)>0.0001)
A moins que A soit égal à B je ne vois pas comment la précision va passer au dessous de 1

Ensuite, lors que tu écris B = C; ou A = C; tu n'as pas l'impression que tu vas perdre un peu en précision sur la division de l'intervalle?

Avec n'importe quel débogueur, tu aurais pu voir ça en quelques secondes.

[Jack]

        if (fct_p(C, n, po) == 0)
            {
             return C;
            }

Tu peux supprimer ces lignes car il est fort peu probable d'atteindre exactement la racine.

       printf("la valeur introuvable");
        return -1;

je ne comprends pas ceci non plus. Si tu sors de la boucle while, c'est que tu as atteint la précision et il suffit de retourner (B+A)/2 qui est la racine approchée

[imoca]

#define epsilon  0.0001

double rac(int A,int B, int n,double poly[nmax]){
    double a=A,b=B;
    double C = (A+B)/2.0;
    if(A>B || fct_p(A, n, poly)*fct_p(B, n, poly)>0){
        printf("la valeur introuvable");
        return -1;
    }
    while(!(fct_p(C, n, poly)<epsilon && fct_p(C, n, poly)>-epsilon))  {
        C = (a+b)/2.0;
        printf("%f %f : %f \n",a,b,fct_p(C, n, poly));
        if (fct_p(C, n, poly) == 0){
            return C;
        }
        else{
            if(fct_p(C, n, poly)*fct_p(a,n,poly)< 0){
                b = C;
            }
            else{
                a = C;
            }
        }
    }

    return C;
}

[Jack]

imoca, tu as trop tendance à donner la solution finale, ce qui n'est pas bon didactiquement de mon point de vue. De plus tu frustres 221 de la joie d'arriver "seul" à un code qui fonctionne.

[221]

j avais fini par trouver avant la solution finale d imoca grace a vos indications quand meme je l avoue
merci