Что значит число двойной точности

Тип данных double в C, C++ и C#

Тип данных double – 64-разрядная переменная с плавающей запятой

Тип double — это основной тип данных, который используется для переменных, содержащих числа с дробной частью. Double используется в C , C++ , C# и других языках программирования. Он может представлять как дробные, так и целые значения длинной до 15 знаков.

Применение DOUBLE

Тип float раньше использовался из-за того, что он был меньше double и позволял быстрее работать с тысячами и миллионами чисел с плавающей запятой. Но вычислительная мощность новых процессоров выросла настолько, что преимуществами float перед double можно пренебречь. Многие программисты считают double типом по умолчанию для чисел с плавающей запятой.

DOUBLE, FLOAT И INT

Другие числовые типы данных — это float и int . Типы данных double и float похожи, но отличаются точностью и диапазоном:

• Float — 32-битный тип, вмещающий семь цифр. Его диапазон — примерно от 1.5 х 215; 10 -45 до 3.4 х 10 38 ;
• Double — 64-битный тип, вмещающий 15 или 16 цифр с диапазоном от 5.0 х 10 345 to 1.7 х 10 308 .

Int также относится к числовым типам данных, но с ним можно использовать только целые числа, которым не нужна запятая. Таким образом, int содержит только целые числа, но при этом занимает меньше места. Он позволяет быстрее совершать математические операции, а также эффективнее других типов данных использует кэш-память и пропускную способность соединения.

Пожалуйста, опубликуйте свои мнения по текущей теме статьи. За комментарии, дизлайки, лайки, подписки, отклики огромное вам спасибо!

Пожалуйста, опубликуйте свои мнения по текущей теме статьи. Мы крайне благодарны вам за ваши комментарии, подписки, отклики, лайки, дизлайки!

Источник

4.8 – Числовые типы с плавающей точкой

Целочисленные типы отлично подходят для подсчета целых чисел, но иногда нам нужно хранить очень большие числа или числа с дробной частью. Переменная типа с плавающей точкой (запятой) – это переменная, которая может содержать действительное число, например 4320,0, -3,33 или 0,01226. «Плавающая» в названии «с плавающей точкой» указывает на то, что десятичная точка может «плавать»; то есть она может поддерживать переменное количество цифр до и после себя.

Существует три разных типа данных с плавающей точкой: float , double и long double . Как и в случае с целыми числами, C++ не определяет фактические размеры этих типов (но гарантирует минимальные размеры). В современных архитектурах представление с плавающей точкой почти всегда соответствует двоичному формату IEEE 754. В этом формате float составляет 4 байта, double – 8, а long double может быть эквивалентно double (8 байтов), 80 битам (часто с дополнением до 12 байтов) или 16 байтам.

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

Категория	Тип	Минимальный размер	Типовой размер
С плавающей запятой	float	4 байта	4 байта
double	8 байт	8 байт
long double	8 байт	8, 12 или 16 байт

Ниже показан пример определения чисел с плавающей запятой:

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

Обратите внимание, что по умолчанию литералы с плавающей точкой по умолчанию имеют тип double . Суффикс f используется для обозначения литерала типа float .

Лучшая практика

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

Предупреждение

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

Печать чисел с плавающей точкой

Теперь рассмотрим следующую простую программу:

Результаты работы этой, казалось бы, простой программы могут вас удивить:

В первом случае std::cout напечатал 5, хотя мы ввели 5.0. По умолчанию std::cout не будет печатать дробную часть числа, если она равна 0.

Во втором случае число печатается так, как мы и ожидали.

В третьем случае напечаталось число в экспоненциальном представлении (если вам нужно освежить в памяти экспоненциальное представление, смотрите урок «4.7 – Введение в экспоненциальную запись»).

Диапазоны значений типов с плавающей точкой

Предполагая, что используется представление IEEE 754:

Размер	Диапазон значений	Точность
4 байта	от ±1,18 × 10 -38 до ±3,4 × 10 38	6-9 значащих цифр, обычно 7
8 байт	от ±2,23 × 10 -308 до ±1,80 × 10 308	15-18 значащих цифр, обычно 16
80 бит (обычно используется 12 или 16 байт)	от ±3,36 × 10 -4932 до ± 1,18 × 10 4932	18-21 значащая цифра
16 байт	от ±3,36 × 10 -4932 до ± 1,18 × 10 4932	33-36 значащих цифр

80-битный тип с плавающей запятой – это своего рода историческая аномалия. На современных процессорах он обычно реализуется с использованием 12 или 16 байтов (что является более естественным размером для обработки процессорами).

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

Точность с типов плавающей запятой

Рассмотрим дробь 1/3. Десятичное представление этого числа – 0,33333333333333… с тройками, уходящими в бесконечность. Если бы вы писали это число на листе бумаги, ваша рука в какой-то момент устала бы, и вы, в конце концов, прекратили бы писать. И число, которое у вас осталось, будет близко к 0,3333333333…. (где 3-ки уходят в бесконечность), но не совсем.

На компьютере число бесконечной длины потребует для хранения бесконечной памяти, но обычно у нас есть только 4 или 8 байтов. Эта ограниченная память означает, что числа с плавающей запятой могут хранить только определенное количество значащих цифр – и что любые дополнительные значащие цифры теряются. Фактически сохраненное число будет близко к необходимому, но не точно.

Точность числа с плавающей запятой определяет, сколько значащих цифр оно может представлять без потери информации.

При выводе чисел с плавающей точкой std::cout по умолчанию имеет точность 6, то есть предполагает, что все переменные с плавающей точкой имеют только до 6 значащих цифр (минимальная точность с плавающей точкой), и, следовательно, он будет отсекать всё, что идет дальше.

Следующая программа показывает усечение std::cout до 6 цифр:

Эта программа выводит:

Обратите внимание, что каждое из напечатанных значений имеет только 6 значащих цифр.

Также обратите внимание, что std::cout в некоторых случаях переключился на вывод чисел в экспоненциальном представлении. В зависимости от компилятора показатель степени обычно дополняется до минимального количества цифр. Не беспокойтесь, 9.87654e+006 – это то же самое, что 9.87654e6 , только с некоторым количеством дополнительных нулей. Минимальное количество отображаемых цифр показателя степени зависит от компилятора (Visual Studio использует 3, некоторые другие в соответствии со стандартом C99 используют 2).

Число цифр точности переменной с плавающей запятой зависит как от размера (у float точность меньше, чем у double ), так и от конкретного сохраняемого значения (некоторые значения имеют большую точность, чем другие). Значения float имеют точность от 6 до 9 цифр, при этом большинство значений float имеют не менее 7 значащих цифр. Значения double имеют от 15 до 18 цифр точности, при этом большинство значений double имеют не менее 16 значащих цифр. Значения long double имеет минимальную точность 15, 18 или 33 значащих цифр в зависимости от того, сколько байтов этот тип занимает.

Мы можем переопределить точность по умолчанию, которую показывает std::cout , используя функцию манипулятора вывода с именем std::setprecision() . Манипуляторы вывода изменяют способ вывода данных и определяются в заголовке iomanip .

Поскольку с помощью std::setprecision() мы устанавливаем точность в 16 цифр, каждое из приведенных выше чисел печатается с 16 цифрами. Но, как видите, числа определенно неточны до 16 цифр! А поскольку числа float менее точны, чем числа double , число ошибок у float больше.

Проблемы с точностью влияют не только на дробные числа, они влияют на любое число со слишком большим количеством значащих цифр. Рассмотрим большое число:

123456792 больше, чем 123456789 . Значение 123456789.0 имеет 10 значащих цифр, но значения float обычно имеют точность 7 цифр (и результат 123456792 точен только до 7 значащих цифр). Мы потеряли точность! Когда теряется точность из-за того, что число не может быть точно сохранено, это называется ошибкой округления.

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

Лучшая практика

Если нет ограничений по использованию памяти, отдавайте предпочтение использованию double вместо float , поскольку неточность float часто приводит к погрешностям.

Ошибки округления затрудняют сравнение чисел с плавающей запятой

С числами с плавающей запятой сложно работать из-за неочевидных различий между двоичными (как хранятся данные) и десятичными (как мы думаем) числами. Рассмотрим дробь 1/10. В десятичном формате ее легко представить как 0,1, и мы привыкли думать о 0,1 как о легко представимом числе с 1 значащей цифрой. Однако в двоичном формате 0,1 представлен бесконечной последовательностью: 0,00011001100110011… Из-за этого, когда мы присваиваем 0,1 числу с плавающей точкой, мы сталкиваемся с проблемами точности.

Эффект от этого можно увидеть в следующей программе:

Эта программ выводит следующее:

Как и ожидалось, в первой строке std::cout печатает 0,1 .

Во второй строке, где std::cout показывает нам 17-значную точность, мы видим, что d на самом деле не совсем равно 0,1 ! Это связано с тем, что из-за ограниченной памяти double пришлось усекать приближение. В результате получается число с точностью до 16 значащих цифр (что гарантирует тип double ), но это число не равно 0,1. Ошибки округления могут сделать число немного меньше или немного больше, в зависимости от того, где происходит усечение.

Ошибки округления также могут иметь неожиданные последствия:

Хотя можно было ожидать, что d1 и d2 должны быть равны, мы видим, что это не так. Если бы мы сравнивали d1 и d2 в программе, программа, вероятно, не работала бы так, как ожидалось. Поскольку числа с плавающей запятой имеют тенденцию быть неточными, их сравнение обычно проблематично – мы обсудим эту тему (и решения) подробнее в уроке «5.6 – Операторы отношения и сравнение значений с плавающей запятой».

Последнее замечание об ошибках округления: математические операции (такие как сложение и умножение), как правило, приводят к увеличению ошибок округления. Таким образом, даже несмотря на то, что 0,1 имеет ошибку округления в 17-й значащей цифре, когда мы складываем 0,1 десять раз, ошибка округления добралась бы и до 16-й значащей цифры. Продолжение операций приведет к тому, что эта ошибка станет всё более значительной.

Ключевые выводы

Ошибки округления возникают, когда число не может быть сохранено точно. Это может произойти даже с простыми числами, например, 0,1 . Таким образом, ошибки округления могут происходить постоянно. Ошибки округления – не исключение, а правило. Никогда не предполагайте, что ваши числа с плавающей запятой точны.

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

NaN и Inf

Существует две особые категории чисел с плавающей запятой. Первая – Inf , которая представляет бесконечность. Inf может быть положительной или отрицательной. Вторая – NaN , что означает «Not a Number» (не число). Существует несколько различных типов NaN (которые мы здесь обсуждать не будем). NaN и Inf доступны только в том случае, если компилятор для чисел с плавающей запятой использует определенный формат (IEEE 754). Если используется другой формат, следующий код приводит к неопределенному поведению.

Ниже приведена программа, показывающая все эти три категории чисел с плавающей точкой:

И результаты работы этой программы при использовании Visual Studio 2008 в Windows:

INF означает бесконечность, а IND означает неопределенность. Обратите внимание, что результаты печати Inf и NaN зависят от платформы, поэтому ваши результаты могут отличаться.

Лучшая практика

Вообще избегайте деления на 0, даже если ваш компилятор поддерживает это.

Заключение

Подводя итог, вы должны помнить две вещи о числах с плавающей запятой:

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

Источник

В чем разница между операциями с плавающей запятой одинарной и двойной точности?

В чем разница между операцией с плавающей запятой одинарной точности и операцией с плавающей запятой двойной точности?

Меня особенно интересуют практические термины в отношении игровых приставок. Например, есть ли в Nintendo 64 64-битный процессор и означает ли это, что он способен выполнять операции с плавающей запятой двойной точности? Могут ли PS3 и Xbox 360 выполнять операции с плавающей запятой двойной точности или только одинарную точность, и в общем случае используются возможности двойной точности (если они существуют?).

Примечание: Nintendo 64 имеет 64-битный процессор, однако:

Многие игры использовали 32-битный режим обработки чипа, так как для 3D-игр обычно не требуется большая точность данных, доступная для 64-битных типов данных, а также тот факт, что обработка 64-битных данных использует вдвое больше оперативной памяти и кеша. и пропускная способность, тем самым снижая общую производительность системы.

Термин «двойная точность» является чем-то неправильным, потому что точность на самом деле не двойная.
Слово double происходит от того факта, что число с двойной точностью использует вдвое больше бит, чем обычное число с плавающей запятой.
Например, если число с одинарной точностью требует 32 бита, его аналог с двойной точностью будет иметь длину 64 бита.

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

Формат двойной точности IEEE на самом деле имеет более чем в два раза больше бит точности, чем формат одинарной точности, а также гораздо больший диапазон.

Единственная Точность

Стандартное представление IEEE с плавающей запятой одинарной точности требует 32-битного слова, которое может быть представлено как пронумерованное от 0 до 31 слева направо.

• Первый бит это знаковый бит, S,
• следующие восемь битов — это биты экспоненты , ‘E’, и

последние 23 бита являются дробью ‘F’:

Значение V, представленное словом, может быть определено следующим образом:

• Если E = 255 и F ненулевой, то V = NaN («Не число»)
• Если E = 255 и F равно нулю, а S равно 1, то V = -Infinity
• Если E = 255 и F равно нулю, а S равно 0, то V = бесконечность
• Если 0 тогда, V=(-1)**S * 2 ** (E-127) * (1.F) где «1.F» предназначен для представления двоичного числа, созданного префиксом F с неявным начальным 1 и двоичной точкой.
• Если E = 0 и F ненулевой, то V=(-1)**S * 2 ** (-126) * (0.F) . Это «ненормализованные» значения.
• Если E = 0 и F равно нулю, а S равно 1, то V = -0
• Если E = 0 и F равно нулю, а S равно 0, то V = 0

Двойная точность

Стандартное представление IEEE двойной точности с плавающей запятой требует 64-битного слова, которое может быть представлено как пронумерованное от 0 до 63 слева направо.

• Первый бит это знаковый бит, S,
• следующие одиннадцать битов — это биты экспоненты , ‘E’, и

последние 52 бита являются дробью ‘F’:

Значение V, представленное словом, может быть определено следующим образом:

• Если E = 2047 и F ненулевой, то V = NaN («Не число»)
• Если E = 2047 и F равно нулю, а S равно 1, то V = -Infinity
• Если E = 2047 и F равно нулю, а S равно 0, то V = бесконечность
• Если 0 тогда, V=(-1)**S * 2 ** (E-1023) * (1.F) где «1.F» предназначен для представления двоичного числа, созданного префиксом F с неявным начальным 1 и двоичной точкой.
• Если E = 0 и F ненулевое, то V=(-1)**S * 2 ** (-1022) * (0.F) это «ненормализованные» значения.
• Если E = 0 и F равно нулю, а S равно 1, то V = -0
• Если E = 0 и F равно нулю, а S равно 0, то V = 0

Ссылка:
Стандарт ANSI / IEEE 754-1985,
Стандарт для двоичной арифметики с плавающей точкой.

Источник