racine nième d'un nombre

J'ai écrit un programme pour calculer la racine nième d'un nombre jusqu'à 2 décimales. par exemple 4ème racine de 81 3., 3ème racine de 125 est 5.Sa fonctionne parfaitement sauf pour la 2ème racine de 4. Il donne à la sortie de 1,99 au lieu de 2. Voici le code.

#include<stdio.h>
int main(int argc, char **argv)
{
    double root1(int,int);
    int n;
    int num1;
    double root;
    printf("\n\n-----------This is the programme to find the nth root of a number-----------\n\n");
    printf("Enter a nuber greater then 1 : ");
    scanf("%d",&num1);
    if(num1>1)
    {
        printf("Enter the value for 'n'(the root to be calculated) : ");
        scanf("%d",&n);
        root = root1(num1,n);
        printf("%d th Root of %d is %f\n\n", n,num1,root);
    }
    else
        printf("wrong entry");
    return 0;
}

double root1(int a, int b)
{
    int j;
    double i,k;
    double incre = 0.01;
    for(i=1; i<=a; i = i+incre)
    {
        for(j=0;j<b;j++)
        {
            k=k*i;
        }
        if(a<k)
        {
            return(i-incre);
            break;
        }
        else
            k=1;
    }
}

Je l'ai essayé pendant des heures, mais ne peut pas la corriger.
quelqu'un peut-il corriger de cette?? Je serai très reconnaissant.

  • Veuillez utiliser le bouton de code: il aide les autres à lire votre code.
  • Désolé pour la gêne occasionnée. Je suis nouveau ici. La prochaine fois je vais prendre soin de cela.
  • ques édité. au lieu de 3, c'est jusqu'à 2 décimales.
  • Que faire si vous changez incre à 0.001? Cela vous aide?
  • N'aide pas. 0.0078125 a plus de sens, puisque cela a une représentation binaire.
  • Si vous avez besoin de calculer arbitraire racines, vous pouvez utiliser double root = pow(input, 1.0 / base). Par exemple, la 3ème racine à 10, peut être calculé par pow(10, 1.0 / 3), de retour 2.15443.... Si vous êtes à la recherche pour plus de précision, découvrez les formules à en.wikipedia.org/wiki/Nth_root.

InformationsquelleAutor narayanpatra | 2010-08-16
  1. 10

    Vous avez besoin de lire "Ce Que Chaque Ordinateur Scientifique Doit Savoir À Propos De L'Arithmétique À Virgule Flottante".

    Nombres en virgule flottante—qui sont ce qui est normalement utilisé pour représenter des nombres non entiers—sont intrinsèquement limitées. Ces limites permettent une bonne performance, mais au coût de telles anomalies.

    InformationsquelleAutor Richard
  2. 5

    C'est parce que les ordinateurs ne peuvent pas gérer des nombres réels correctement.

    http://en.wikipedia.org/wiki/Floating_point#Accuracy_problems

    • Plus précisément, les ordinateurs ne peuvent pas gérer précision infinie. Tous les objets, y compris tous les numéros, qui comprend tous les nombres à virgule flottante, sont représentés par un ensemble fini d'octets.
    • plus précisément encore: ordinateurs poignée indéfinie de précision comme le font les humains: symboliquement.
    InformationsquelleAutor Federico klez Culloca
  3. 5

    La réponse, comme avec la plupart des virgule flottante problèmes, c'est que C fonctionne avec une précision limitée. Et les flotteurs sont binaires. Ils ne peuvent pas représenter avec exactitude le nombre décimal 1.99 - il sera probablement une valeur proche de comme 1.990000000023.....

    Lien Standard pour ces problèmes: Ce Que Tout Informaticien Devez Savoir À Propos De Virgule Flottante

    Il y a heureusement une solution simple (mais pas parfait!). Trouver la racine de (num*10000.0), en utilisant des incréments de un. Ce sera bien sûr 100 fois la racine que vous voulez vraiment. Par conséquent, les deux derniers chiffres sont les "décimales" vous avez voulu. Vous trouverez que la racine de 40000.0 est précisément 200.0 Cela fonctionne parce que 1.0 peut être parfaitement représentés.

    Le prix que vous payez pour la précision à cette fin, c'est que vous perdez de l'autre côté - en multipliant par 10000 signifie que vous aurez une perte de précision dans les chiffres plus élevés. Des solutions faciles viennent rarement sans inconvénients, désolé.

    • mais pourquoi il ne va pas jusqu'à 2. Mon état de pause est un<k. si nous sommes à l'entrée un = 4, alors la valeur de k est la place de 1,99. Donc il ne peut pas être supérieure à 4. Pourquoi la boucle est la rupture?
    • Même chose. Il ne peut pas représenter le nombre 0.01 soit. Il va quelque chose comme être 0.009999999999984.... Par conséquent, de 0,01 + 0.01 sera 0.019999999999968... . Et 0.01 + 0.01 + 0.01 + 0.01 (199 fois) va provoquer 198 les erreurs d'arrondi.
    InformationsquelleAutor MSalters
  4. 2

    Bien, si vous voulez 0.01 précision, vous avez besoin de l'étape de 0,005 ou moins, puis effectuez l'arrondissement.
    La meilleure façon est de simplement utiliser pow(num1, 1/n) 🙂

    InformationsquelleAutor BarsMonster
  5. 2

    prendre k=1;

    #include<stdio.h>
int main(int argc, char **argv)
{
    double root1(int,int);
    int n;
    int num1;
    double root;
    printf("\n\n-----------This is the programme to find the nth root of a number-----------\n\n");
    printf("Enter a nuber greater then 1 : ");
    scanf("%d",&num1);
    if(num1>1)
    {
        printf("Enter the value for 'n'(the root to be calculated) : ");
        scanf("%d",&n);
        root = root1(num1,n);
        printf("%d th Root of %d is %f\n\n", n,num1,root);
    }
    else
        printf("wrong entry");
    return 0;
}

double root1(int a, int b)
{
    int j;
    double i,k=1;
    double incre = 0.01;
    for(i=1; i<=a; i = i+incre)
    {
        for(j=0;j<b;j++)
        {
            k=k*i;
        }
        if(a<k)
        {
            return(i-incre);
            break;
        }
        else
            k=1;
    }
}
    InformationsquelleAutor n99
  6. 1

    ce MSalters dit. essayez de faire incre plus petit pour voir comment la valeur progressivement des approches 2.0. vous pourriez être plus "interne" de précision (c'est à dire incre) que ce que vous retourner, et arrondir le résultat interne à, disons, 2 chiffres. De cette façon, vous pouvez couvrir les problèmes d'arrondi (mais c'est juste un non testé suspicion)

    • Il ne fonctionne pas, en fait, plus les erreurs d'arrondi s'accumulent. Actuellement, il dispose de 199 erreurs d'arrondi, le tout à 1up. La diminution de la valeur de l'échelon de 0,001 signifie que vous aurez 1999 erreurs d'arrondi, toujours à 1 place. Maintenant 1up de 0,001 est un peu plus petit, mais ce n'est pas le progrès. Aussi, vous êtes à l'ajout de 1998 fois au lieu de 198 fois, ce qui signifie que vous avez plus mais les petites erreurs d'arrondi.
    InformationsquelleAutor Nicolas78
  7. 0

    Doubles ne sont pas nécessairement représenter des nombres à virgule flottante de précision. Essayez d'utiliser un type de données décimal à la place (si c a une telle pense, désolé ne me souviens pas). C# a virgule, Java a BigDecimal des classes pour représenter des nombres à virgule flottante de précision.

    InformationsquelleAutor Simon
  8. 0

    Un petit "incre" valeur travail, j'ai utilisé 0,001 et root1 retourné 2.00 pour la racine carrée de 4.

    Aussi, si vous voulez la réponse à être affiché à 2 décimales, utilisez %.2f lorsque vous imprimez la racine.

    InformationsquelleAutor
  9. 0
    #include <iostream>
#include<math.h>
using namespace std;
int main()
{
double n,m;
cin>>n;
cin>>m;
m= pow(m, (1/n));
cout<<m;
return 0;
}

    Pourquoi écrire un tel énorme de code.Cela fonctionne parfaitement jusqu'à ce que j'changement à double int.

    • Êtes-vous essayer d'aider l'OP ou de l'insulter?
    InformationsquelleAutor M A SIDDIQUI