it-swarm.com.ru

В чем разница между float и double?

Я читал о разнице между двойной точностью и одинарной точностью. Однако в большинстве случаев float и double кажутся взаимозаменяемыми, т. Е. Использование одного или другого, похоже, не влияет на результаты. Это действительно так? Когда поплавки и двойники взаимозаменяемы? Каковы различия между ними?

351
VaioIsBorn

Огромная разница.

Как видно из названия, double имеет в 2 раза большую точность, чем float[1], В общем случае double имеет 15 десятичных цифр точности, в то время как float имеет 7.

Вот как рассчитывается количество цифр:

double имеет 52 бита мантиссы + 1 скрытый бит: log (253) ÷ log (10) = 15,95 цифр

float имеет 23 бита мантиссы + 1 скрытый бит: log (224) ÷ log (10) = 7,22 цифры

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

float a = 1.f / 81;
float b = 0;
for (int i = 0; i < 729; ++ i)
    b += a;
printf("%.7g\n", b); // prints 9.000023

в то время как

double a = 1.0 / 81;
double b = 0;
for (int i = 0; i < 729; ++ i)
    b += a;
printf("%.15g\n", b); // prints 8.99999999999996

Кроме того, максимальное значение с плавающей точкой составляет около 3e38, а double - около 1.7e308, поэтому использование float может привести к «бесконечности» (то есть специальному числу с плавающей запятой) гораздо проще, чем double для чего-то простого, например, вычисление факториала 60.

Во время тестирования, возможно, несколько тестовых примеров содержат эти огромные числа, которые могут вызвать сбой ваших программ, если вы используете float.


Конечно, иногда даже double недостаточно точен, поэтому у нас иногда есть long double[1] (приведенный выше пример дает 9.000000000000000066 на Mac), но все типы с плавающей запятой страдают от ошибок округления, поэтому, если точность очень важна (например, обработка денег), вы должны использовать int или класс дроби.


Кроме того, не используйте += для суммирования большого числа чисел с плавающей запятой, так как ошибки быстро накапливаются. Если вы используете Python, используйте fsum. В противном случае попробуйте реализовать алгоритм суммирования Кахана .


[1]: стандарты C и C++ не определяют представление float, double и long double. Вполне возможно, что все три реализованы как IEEE двойной точности. Тем не менее, для большинства архитектур (gcc, MSVC; x86, x64, ARM) floatявляется действительно числом с плавающей запятой одинарной точности IEEE (binary32), а doubleявляется числом с плавающей запятой двойной точности IEEE (binary64).

434
kennytm

Вот что говорят стандартные стандарты C99 (ISO-IEC 9899 6.2.5 §10) или C++ 2003 (ISO-IEC 14882-2003 3.1.9 §8):

Существует три типа с плавающей запятой: float, double и long double. Тип double обеспечивает, по крайней мере, такую ​​же точность, что и float, а тип long double обеспечивает, по крайней мере, такую ​​же точность, как и double. Набор значений типа float является подмножеством набора значений типа double; набор значений типа double является подмножеством набора значений типа long double.

Стандарт C++ добавляет:

Представление значений типов с плавающей запятой определяется реализацией.

Я бы посоветовал взглянуть на превосходное Что должен знать каждый ученый-компьютерщик об арифметике с плавающей запятой которое подробно описывает стандарт IEEE с плавающей запятой. Вы узнаете о деталях представления и поймете, что есть компромисс между величиной и точностью. Точность представления с плавающей запятой увеличивается с уменьшением величины, поэтому числа с плавающей запятой от -1 до 1 - это числа с наибольшей точностью.

51
Gregory Pakosz

Дано квадратное уравнение: x2- 4.0000000 x + 3.9999999 = 0, точные корни до 10 значащих цифр, r1= 2.000316228 и r2= 1,999683772.

Используя float и double, мы можем написать тестовую программу:

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

void dbl_solve(double a, double b, double c)
{
    double d = b*b - 4.0*a*c;
    double sd = sqrt(d);
    double r1 = (-b + sd) / (2.0*a);
    double r2 = (-b - sd) / (2.0*a);
    printf("%.5f\t%.5f\n", r1, r2);
}

void flt_solve(float a, float b, float c)
{
    float d = b*b - 4.0f*a*c;
    float sd = sqrtf(d);
    float r1 = (-b + sd) / (2.0f*a);
    float r2 = (-b - sd) / (2.0f*a);
    printf("%.5f\t%.5f\n", r1, r2);
}   

int main(void)
{
    float fa = 1.0f;
    float fb = -4.0000000f;
    float fc = 3.9999999f;
    double da = 1.0;
    double db = -4.0000000;
    double dc = 3.9999999;
    flt_solve(fa, fb, fc);
    dbl_solve(da, db, dc);
    return 0;
}  

Запуск программы дает мне:

2.00000 2.00000
2.00032 1.99968

Обратите внимание, что числа не велики, но вы все равно получаете эффекты отмены, используя float.

(На самом деле, вышеупомянутое не является лучшим способом решения квадратных уравнений с использованием чисел с плавающей запятой одинарной или двойной точности, но ответ остается неизменным, даже если кто-то использует более стабильный метод .)

26
Alok Singhal
  • Двойное число равно 64, а одинарная точность (Float) составляет 32 бита.
  • Двойник имеет большую мантиссу (целые биты действительного числа).
  • Любые неточности будут в два раза меньше.
19
graham.reeds

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

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

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

11
Dolbz

Тип float, 32 бита, имеет точность 7 цифр. Хотя он может хранить значения с очень большим или очень маленьким диапазоном (+/- 3,4 * 10 ^ 38 или * 10 ^ -38), он имеет только 7 значащих цифр.

Тип double, длиной 64 бита, имеет больший диапазон (* 10 ^ +/- 308) и точность до 15 цифр.

Тип long double номинально равен 80 битам, хотя для данной пары компилятор/ОС может сохранять его как 12-16 байтов для целей выравнивания. Длинный дубль имеет показатель, который просто смехотворно огромен и должен иметь точность до 19 цифр. Microsoft, в своей бесконечной мудрости, ограничивает long double до 8 байтов, так же, как обычный double.

Вообще говоря, просто используйте тип double, когда вам нужно значение/переменную с плавающей запятой. Литеральные значения с плавающей запятой, используемые в выражениях, будут по умолчанию рассматриваться как двойные, и большинство математических функций, возвращающих значения с плавающей запятой, возвращают двойные. Вы избавите себя от многих головных болей и типов, если вы просто используете double.

8
Zain Ali

Поплавки имеют меньшую точность, чем двойные. Хотя вы уже знаете, прочитайте Что WE следует знать об арифметике с плавающей точкой для лучшего понимания.

8
N 1.1

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

#include <iostream>
#include <iomanip>

int main(){
  for(float t=0;t<1;t+=0.01){
     std::cout << std::fixed << std::setprecision(6) << t << std::endl;
  }
}

Результат

0.000000
0.010000
0.020000
0.030000
0.040000
0.050000
0.060000
0.070000
0.080000
0.090000
0.100000
0.110000
0.120000
0.130000
0.140000
0.150000
0.160000
0.170000
0.180000
0.190000
0.200000
0.210000
0.220000
0.230000
0.240000
0.250000
0.260000
0.270000
0.280000
0.290000
0.300000
0.310000
0.320000
0.330000
0.340000
0.350000
0.360000
0.370000
0.380000
0.390000
0.400000
0.410000
0.420000
0.430000
0.440000
0.450000
0.460000
0.470000
0.480000
0.490000
0.500000
0.510000
0.520000
0.530000
0.540000
0.550000
0.560000
0.570000
0.580000
0.590000
0.600000
0.610000
0.620000
0.630000
0.640000
0.650000
0.660000
0.670000
0.680000
0.690000
0.700000
0.710000
0.720000
0.730000
0.740000
0.750000
0.760000
0.770000
0.780000
0.790000
0.800000
0.810000
0.820000
0.830000
0.839999
0.849999
0.859999
0.869999
0.879999
0.889999
0.899999
0.909999
0.919999
0.929999
0.939999
0.949999
0.959999
0.969999
0.979999
0.989999
0.999999

Как вы можете видеть после 0,83, точность значительно снижается.

Однако, если я установлю t как double, такой проблемы не будет.

Мне потребовалось пять часов, чтобы понять эту незначительную ошибку, которая разрушила мою программу.

7
Elliscope Fang

При использовании чисел с плавающей запятой вы не можете полагать, что ваши локальные тесты будут точно такими же, как тесты, выполняемые на стороне сервера. Среда и компилятор, вероятно, различаются в вашей локальной системе и в том месте, где выполняются финальные тесты. Я видел эту проблему много раз в некоторых соревнованиях TopCoder, особенно если вы пытаетесь сравнить два числа с плавающей запятой.

3
Tuomas Pelkonen

Встроенные операции сравнения отличаются тем, что при сравнении двух чисел с плавающей запятой разница в типе данных (то есть с плавающей запятой или двойной) может привести к разным результатам.

2
Johnathan Lau

Разница между float и double заключается в том, что double имеет большее значение точности, чем переменные с плавающей точкой . Когда вы объявляете переменную как float, она позволяет вводить только 6 десятичных разрядов после десятичной точки ..__ переменная с плавающей точкой float f= 2.3333333; // 7 знаков после запятой - это максимум, который вы можете сохранить

Даже если вы сохраните значение, которое больше десяти цифр после десятичной запятой, оно не сохранит все число, а сохранит только первые шесть цифр после десятичной запятой .... Также вы получите ошибку если вы попытаетесь сохранить более 7 цифр после десятичной точки для этой переменной. В этом случае вам нужно инициализировать его следующим образом -float f= 2.3333334443f; // тогда компилятор интерпретирует это как 2.3333334

В случае Double, он будет хранить до 15 цифр после десятичной точки . Пример: double d=1.222222345675423; // 15 цифр после десятичной точки

0
Sravanti Malapaka