корень числа

Question

Я написал программу для вычисления n-го корня числа до 2 десятичных знаков. например, 4-й корень из 81 - 3., 3-й корень из 125 - 5. Хорошо работает, за исключением 2-го корня из 4. Он дает вывод 1.99 вместо 2. Вот код.

#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;
    }
}

Я пробовал это часами, но не могу исправить это. кто-нибудь может отладить это ?? Я буду очень благодарен.

Answer 1

Вам нужно прочитать «Что должен знать каждый учёный об арифметике с плавающей точкой» .

Числа с плавающей точкой, которые обычно используются для представления нецелых чиселпо своей сути ограничен.Эти ограничения обеспечивают хорошую производительность, но за счет таких аномалий.

Answer 2

Это потому, что компьютеры не могут правильно обрабатывать реальные числа.

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

Answer 3

Ответ, как и в большинстве задач с плавающей точкой, заключается в том, что C работает с ограниченной точностью.И поплавки являются двоичными.Они не могут точно представлять десятичное число 1.99 - оно, вероятно, будет близким значением, например 1.990000000023.....

Стандартная ссылка для этих задач: Что должен знать каждый учёный-компьютерщик с плавающей точкой

К счастью, есть простое решение (но не идеальное!)Найдите корень (num * 10000.0), используя приращение в единицу.Это, конечно, будет в 100 раз больше, чем вы хотите.Следовательно, последние две цифры - это те «десятичные знаки», которые вы хотели.Вы обнаружите, что корень 40000.0 точно равен 200.0. Это работает, потому что 1.0 может быть прекрасно представлено.

Цена, которую вы платите за точность на том конце, состоит в том, что вы теряете его на другом конце - умножение на 10000 означает, что вы получите потерю точности с более высокими числами.Простые решения редко бывают без недостатков, извините.

Answer 4

дубль 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;
    }
}

Answer 5

Ну, если вам нужна точность 0,01, вам нужно шаг 0,005 или меньше, а затем выполнить округление.Лучше всего просто использовать pow (num1, 1 / n): -)

Answer 6

что сказал MSalters. попробуйте уменьшить incre, чтобы увидеть, как значение постепенно приближается к 2,0. Возможно, вы захотите иметь более высокую «внутреннюю» точность (т.е. увеличить), чем то, что вы возвращаете, и округлить внутренний результат, скажем, до 2 цифр. Таким образом, вы могли бы покрыть эти проблемы округления (но это просто непроверенное подозрение)

Answer 7

#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;
}

Зачем писать такой огромный код. Это прекрасно работает, пока я не изменяю double на int.

Answer 8

Меньшее значение «приращения» должно работать, я использовал 0,001, а root1 вернул 2,00 для квадратного корня из 4.

Также, если вы хотите, чтобы ответ отображался с точностью до 2 десятичных знаков, используйте%.2f при печати рута.

Answer 9

Двойные числа не обязательно могут точно представлять числа с плавающей запятой.Попробуйте вместо этого использовать десятичный тип данных (если у c такое мнение, извините, не могу вспомнить).C # имеет десятичное число, Java имеет классы BigDecimal для точного представления чисел с плавающей запятой.