Почему pow(10,5) = 9999 в C++

Из-за представления значений с плавающей запятой pow(10.0, 5) может быть 9999,9999999 или что-то в этом роде. Когда вы присваиваете это целому числу, которое было усечено.

РЕДАКТИРОВАТЬ: В случае cout << pow(10.0, 5); похоже, что вывод округлен, но сейчас у меня нет подтверждающего документа, подтверждающего это.

РЕДАКТИРОВАТЬ 2: комментарий, сделанный BoBTFish и этот вопрос подтверждает, что когда pow(10.0, 5) используется непосредственно в cout, оно округляется.

При использовании с дробными показателями pow(x,y) обычно оценивается как exp(log(x)*y); такая формула была бы математически правильной, если бы оценивалась с бесконечной точностью, но на практике может привести к ошибкам округления. Как уже отмечалось, значение 9999,999999999 при приведении к целому числу даст 9999. Некоторые языки и библиотеки постоянно используют такую ​​формулировку при использовании оператора возведения в степень с показателем с плавающей запятой; другие пытаются определить, когда показатель степени является целым числом, и при необходимости используют итерированное умножение. Просматривая документацию по функции pow, оказалось, что она должна работать, когда x отрицательное, а y не имеет дробной части (когда x отрицательное, а `y четное, результат должен быть pow(-x,y); когда y нечетный, результат должен быть -pow(-x,y) Казалось бы логичным, что, когда y не имеет дробной части, библиотека, которая собирается столкнуться с проблемой работы с отрицательным значением x, должна использовать итерированное умножение, но я не знаю какой-либо спецификации, диктующей это.

В любом случае, если вы пытаетесь возвести целое число в степень, почти наверняка лучше использовать математику целых чисел для вычисления или, если целое число, которое нужно возвести, является константой или всегда будет маленьким, просто используйте таблицу поиска. (возведение чисел от 0 до 15 в любую степень, которая уместилась бы в 64-битном целом числе, потребовало бы только таблицы из 4096 элементов).

Из здесь

Глядя на функцию pow(): double pow (double base, double exponent); мы знаем, что все параметры и возвращаемое значение относятся к типу double. Но все переменные num, i и res имеют тип int в приведенном выше коде, при преобразовании int в double или double в int это может привести к потере точности. Например (возможно, не строго), модуль с плавающей запятой (FPU) вычисляет pow(10, 4)=9999.99999999, а затем int(9999.9999999)=9999 путем преобразования типа в C++.

Как это решить?

Решение1

Изменить код:

    const int num = 10;

    for(int i = 0; i < 5; ++i){
       double res = pow(num, i);
       cout << res << endl;
    }

Решение2

Замените блок с плавающей запятой (FPU) с более высокой точностью вычислений в типе double. Например, мы используем SSE в ЦП Windows. В Code::Block 13.12 мы можем сделать следующие шаги для достижения цели: Настройка -> Настройка компилятора -> Компиляция GNU GCC -> Другие параметры, добавьте

-mfpmath=sse -msse3

Картина выглядит следующим образом:

_{(источник: qiniudn.com)}

Что происходит, так это то, что функция pow возвращает двойное значение, поэтому, когда вы это делаете

int i = pow(sections, 5- t -1);  

десятичные дроби 0,99999, и вы получите 9999.

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

Если код в вашем первом примере является именно тем кодом, который вы используете, то у вас есть ошибочная библиотека. Независимо от того, выбираете ли вы std::pow или pow C, который принимает двойные числа, даже если выбрана двойная версия, 10 точно представимо как double. Таким образом, возведение в степень точно можно представить как double. Не должно происходить округления или усечения или чего-либо подобного.

С g++ 4.5 я не мог воспроизвести ваше (странное) поведение, даже используя -ffast-math и -O3.

Теперь я подозреваю, что происходит то, что sections не присваивается литерал 10 напрямую, а вместо этого считывается или вычисляется внутренне, так что его значение является чем-то вроде 9.9999999999999, что при возведении в четвертую степень генерирует номер типа 9999.9999999. Затем оно усекается до отображаемого целого числа 9999.

В зависимости от ваших потребностей вы можете захотеть округлить либо исходный номер, либо окончательный номер перед присвоением в int. Например: int i = pow(sections, 5- t -1) + 0.5; // Add 0.5 and truncate to round to nearest.

В глобальном пространстве имен должна быть какая-то сломанная функция pow. Тогда std::pow "автоматически" используется вместо этого во втором примере из-за ADL.

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

Вы присваиваете результат int. Это принуждает его, усекая число.

Это должно работать нормально:

for(int t= 0; t < 5; t++){
   double i = pow(sections, 5- t -1);  
   cout << i << endl;
}

Что происходит, так это то, что ваш ответ на самом деле 99,9999, а не ровно 100. Это потому, что pow двойное. Итак, вы можете исправить это, используя i = ceil(pow()).

Ваш код должен быть:

const int sections = 10;
for(int t= 0; t < 5; t++){
   int i = ceil(pow(sections, 5- t -1));  
   cout << i << endl;
}