Формат с плавающей запятой двойной точности

редактировать

Формат 64-битного компьютерного числа

Формат с плавающей запятой двойной точности (иногда называется FP64 ) - это формат компьютерных номеров, обычно занимающий 64 бит в памяти компьютера; он представляет широкий динамический диапазон числовых значений с использованием плавающей точки счисления..

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

В стандарте IEEE 754-2008 64-битный формат base-2 официально называется binary64 ; он назывался double в IEEE 754-1985. IEEE 754 определяет дополнительные форматы с плавающей запятой, включая 32-битные представления с основанием 2 одинарной точности и, в последнее время, представления с основанием 10.

Одним из первых языков программирования, обеспечивающих типы данных с плавающей запятой одинарной и двойной точности, был Fortran. До широкого распространения IEEE 754-1985 представление и свойства типов данных с плавающей запятой зависели от производителя компьютера и компьютерной модели, а также от решений, принимаемых разработчиками языка программирования. Например, тип данных с двойной точностью GW-BASIC был 64-битным форматом MBF с плавающей запятой.

Содержание

1 Двоичный формат с плавающей запятой двойной точности IEEE 754: binary64
- 1.1 Экспонентное кодирование
- 1.2 Порядок байтов
- 1.3 Примеры с двойной точностью
- 1.4 Скорость выполнения с арифметикой с двойной точностью
2 Реализации
- 2.1 C и C ++
- 2.2 Fortran
- 2.3 Common Lisp
- 2.4 Java
- 2.5 JavaScript
3 См. Также
4 Примечания и ссылки

IEEE 754 двоичный формат с плавающей запятой двойной точности: binary64

двоичный формат с плавающей запятой двойной точности является широко используемым форматом на ПК из-за его более широкого диапазона по сравнению с плавающей запятой одиночной точности, несмотря на его производительность и Стоимость полосы пропускания. Обычно он известен как двойной. Стандарт IEEE 754 определяет binary64 как имеющий:

знаковый бит : 1 бит
экспонента : 11 бит
значащая точность : 53 бита (52 явно сохранены)

Знаковый бит определяет знак числа (в том числе, когда это число равно нулю, то есть со знаком ).

Поле экспоненты представляет собой 11-битовое целое число без знака от 0 до 2047 в смещенной форме : значение экспоненты 1023 представляет фактический ноль. Показатели варьируются от -1022 до +1023, потому что показатели степени -1023 (все нули) и +1024 (все единицы) зарезервированы для специальных чисел.

53-битная точность значащей дает от 15 до 17 значащих десятичных цифр точность (2 ≈ 1,11 × 10). Если десятичная строка, содержащая не более 15 значащих цифр, преобразована в представление двойной точности IEEE 754, а затем преобразована обратно в десятичную строку с тем же количеством цифр, окончательный результат должен соответствовать исходной строке. Если число двойной точности IEEE 754 преобразовано в десятичную строку, содержащую не менее 17 значащих цифр, а затем преобразовано обратно в представление двойной точности, конечный результат должен соответствовать исходному числу.

Формат записывается с мантиссой, имеющей неявный целочисленный бит значения 1 (за исключением специальных данных, см. кодирование экспоненты ниже). С 52 битами значимой дроби (F), присутствующими в формате памяти, общая точность составляет 53 бита (приблизительно 16 десятичных цифр, 53 log 10 (2) ≈ 15.955). Биты расположены следующим образом:

Действительное значение, принимаемое заданной 64-битной системой данных с двойной точностью с заданной смещенной экспонентой $e {\ displaystyle e}$ $e$ , а 52-битная дробь - это

(- 1) sign (1. b 51 b 50... b 0) 2 × 2 e - 1023 {\ displaystyle (-1) ^ {\ text {sign}} (1.b_ {51} b_ {50}... b_ {0}) _ {2} \ times 2 ^ {e-1023}}

(-1) ^ {\ text {знак}} (1.b_ {51} b_ {50}... b_ {0}) _ {2} \ times 2 ^ {e-1023}

или

(- 1) знак (1 + ∑ i Знак равно 1 52 b 52 - я 2 - я) × 2 е - 1023 {\ displaystyle (-1) ^ {\ text {sign}} \ left (1+ \ sum _ {i = 1} ^ {52} b_ { 52-i} 2 ^ {- i} \ right) \ times 2 ^ {e-1023}}

(-1) ^ {\ text {sign}} \ left (1+ \ sum _ {i = 1} ^ {52} b_ {52-i} 2 ^ {- i} \ right) \ times 2 ^ {e-1023}

Между 2 = 4,503,599,627,370,496 и 2 = 9,007,199,254,740,992 представляемые числа - это в точности целые числа. Для следующего диапазона, от 2 до 2, все умножается на 2, поэтому представляемые числа - четные и т. Д. И наоборот, для предыдущего диапазона от 2 до 2 интервал равен 0,5 и т. Д.

Интервал как часть чисел в диапазоне от 2 до 2 равен 2. Таким образом, максимальная относительная ошибка округления при округлении числа до ближайшего представимого (машинный эпсилон ) равна 2.

11-битная ширина экспоненты позволяет представлять числа от 10 до 10 с точностью до 15–17 десятичных знаков. За счет снижения точности субнормальное представление допускает даже меньшие значения примерно до 5 × 10.

Экспонентное кодирование

Двоичная экспонента с плавающей запятой двойной точности кодируется с использованием смещения - двоичное представление с нулевым смещением 1023; также известный как смещение экспоненты в стандарте IEEE 754. Примеры таких представлений:

e = `00000000001 2`=`001 16`= 1:	$2 1 - 1023 = 2 - 1022 {\ displaystyle 2 ^ {1-1023} = 2 ^ {-1022}}$ ${\ displaystyle 2 ^ {1-1023} = 2 ^ {- 1022}}$	(наименьший показатель степени для нормальных чисел )
e = `01111111111 2`=`3ff 16`= 1023:	$2 1023 - 1023 = 2 0 {\ displaystyle 2 ^ {1023-1023} = 2 ^ {0}}$ ${\ displaystyle 2 ^ {1023- 1023} = 2 ^ {0}}$	(смещение нуля)
e = `10000000101 2`=`405 16`= 1029:	$2 1029 - 1023 = 2 6 { \ displaystyle 2 ^ {1029-1023} = 2 ^ {6}}$ ${\ displaystyle 2 ^ {1029-1023} = 2 ^ {6}}$
e = `11111111110 2`=`7fe 16`= 2046:	$2 2046-1023 = 2 1023 {\ displaystyle 2 ^ {2046-1023} = 2 ^ {1023}}$ ${\ displaystyle 2 ^ {2046-1023} = 2 ^ {1023}}$	(старший показатель степени)

Показатели степени 000 16и 7ff 16имеют особое значение:

00000000000 2=000 16используется для представления нуля со знаком (если F = 0) и субнормальных значений (если F ≠ 0); и
11111111111 2=7ff 16используется для представления ∞ (если F = 0) и NaN (если F ≠ 0),

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

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

(- 1) знак × 2 e - 1023 × 1. дробь {\ displaystyle (-1) ^ {\ text {sign}} \ times 2 ^ {e-1023} \ умножить на 1. {\ text {дробь}}}

{\ displaystyle (-1) ^ {\ text {sign}} \ times 2 ^ {e-1023} \ times 1. {\ Text {дробь}}}

В случае субнормальных (e = 0) число с двойной точностью описывается следующим образом:

(- 1) знак × 2 1 - 1023 × 0. Дробь = (- 1) знак × 2 - 1022 × 0. Дробь {\ displaystyle (-1) ^ {\ text {sign}} \ times 2 ^ {1-1023} \ times 0. {\ текст {дробь}} = (- 1) ^ {\ текст {знак}} \ раз 2 ^ {- 1022} \ раз 0. {\ текст {фракция}}}

{\ displaystyle (-1) ^ {\ text {sign}} \ times 2 ^ {1-1023} \ times 0. {\ Text {дробь}} = (- 1) ^ {\ text {sign}} \ times 2 ^ { -1022} \ times 0. {\ Text {дробь}}}

Порядок байтов

Хотя вездесущие процессоры x86 на сегодняшний день используют память с прямым порядком байтов для всех типов данных (целые числа, числа с плавающей запятой), существует ряд аппаратных архитектур, в которых числа с плавающей запятой представлены в форме с прямым порядком байтов, а целые числа представлены малыми -индийская форма. Существуют процессоры ARM, которые имеют представление с плавающей запятой наполовину с прямым порядком байтов, наполовину с прямым порядком байтов с плавающей запятой для чисел с двойной точностью: оба 32-битных слова хранятся в обратном порядке байтов, как целочисленные регистры, но наиболее значимые один первый. Поскольку существовало много форматов с плавающей запятой, для которых не было стандартного представления «network », в стандарте XDR в качестве представления используется IEEE 754 с прямым порядком байтов. Поэтому может показаться странным, что широко распространенный стандарт IEEE 754 с плавающей запятой не определяет порядок байтов. Теоретически это означает, что даже стандартные данные с плавающей запятой IEEE, записанные на одной машине, могут быть нечитаемы на другой. Однако на современных стандартных компьютерах (т. Е. Реализующих IEEE 754) на практике можно безопасно предположить, что порядок байтов для чисел с плавающей запятой такой же, как и для целых чисел, что делает преобразование простым независимо от типа данных. (Маленькие встроенные системы, использующие специальные форматы с плавающей запятой, могут быть другим вопросом.)

Примеры с двойной точностью

0 01111111111 000000000000000000000000000000000000000000000000 2≙ 3FF0 0000 0000 0000 16 ≙ +2 × 1 = 1

0 01111111111 000000000000000000000000000000000000000000000001 2≙ 3FF0 0000 0000 0001 16 ≙ +2 × (1 + 2) ≈ 1.0000000000000002, наименьшее число>1

0 01111111111 0000000000000000000000000000000000000000000000000010 2≙ 3FF0 0000 0000 0002 16 ≙ +2 × (1 + 2) ≈ 1.0000000000000004

0 10000000000 000000000000000000000000000000000000000000000000 2≙ 4000 0000 0000 0000 16 +2 × 1 = 2

1 10000000000 0000000000000000000000000000000000000000000000000000 2≙ C000 0000 0000 0000 16 ≙ −2 × 1 = −2

0 10000000000 100000000000000000000000000000000000000000000000 2≙ 4008 0000 0000 0000 16 ≙ +2 × 1,1 2 = 11 2 = 3

0 10000000001 000000000000000000000000000000000000 0000000000000000 2≙ 4010 0000 0000 0000 16 ≙ +2 × 1 = 100 2 = 4

0 10000000001 0100000000000000000000000000000000000000000000000000 2≙ 4014 0000 0000 0000 16 ≙ +2 × 1.01 2 = 101 2 = 5

0 10000000001 1000000000000000000000000000000000000000000000000000 2≙ 4018 0000 0000 0000 16 ≙ +2 × 1,1 2 = 110 2 = 6

0 10000000011 0111000000000000000000000000000000000000000000000000 2≙ 4037 0000 0000 0000 16 ≙ +2 × 1.0111 2 = 10111 2 = 23

0 01111111000 100000000000000000000000000000000000000000000000 2≙ 3F88 0000 0000 0000 16 ≙ +2 × 1,1 2 = 0,00000011 2 = 0,01171875 (3/256)

0 00000000000 0000000000000000000000000000000000000000000000000001 2≙ 0000 0000 0000 0001 16 ≙ +2 × 2 = 2. ≈ 4,9406564584124654 × 10 (мин.. субнормальное положительное двойное)

0 00000000000 111111111111111111111111111111111111111111111111 2≙ 000F FFFF FFFF FFFF 16 ≙ +2 × (1-2). ≈ 2,2250738585072009 × 10 (макс. субнормальное) 0 00000000001 000000000000000000000000000000000000000000000000 2≙ 0010 0000 0000 0000 16 ≙ +2 × 1. ≈ 2.2250738585072014 × 10 (мин. Нормальное положительное двойное число)

0 11111111110 111111111111111111111111FF1111111111111111111111FF1111111111 FFFF 16 ≙ +2 × (1 + (1-2)). ≈ 1,7976931348623157 × 10 (макс. Двойной)

0 00000000000 000000000000000000000000000000000000000000000000 2≙ 0000 0000 0000 0000 16 ≙ +0

1 00000000000 0000000000000000000000000000000000000000000000000000 2≙ 8000 0000 0000 0000 16 ≙ −0

0 11111111111 000000000000000000000000000000000000000000000000 2≙ 7FF0 0000 0000 0000 16 ≙ + ∞ (положительная бесконечность)

1 11111111111 0000000000000000000000000000000000000000000000000000 2≙ FFF0 0000 00 00 0000 16 ≙ −∞ (отрицательная бесконечность)

0 11111111111 0000000000000000000000000000000000000000000000000001 2≙ 7FF0 0000 0000 0001 16 ≙ NaN (sNaN на большинстве процессоров, таких как x86 и ARM)

0 11111111111 1000000000000000000000000000000000000000000000000001 2≙ 7FF8 0000 0000 0001 16 ≙ NaN (qNaN на большинстве процессоров, таких как x86 и ARM)

0 11111111111 1111111111111111111111FF11FF1111111111111111111111FF1111111111 16 ≙ NaN (альтернативная кодировка NaN)

0 01111111101 010101010101010101010101010101010101010101010101 2. = 3fd5 5555 5555 5555 16≙ +2 × (1 + 2 + 2 +... + 2). ≈ / 3

0 10000000000 1001001000011111101101010100010001000010110100011000 2. = 4009 21fb 5444 2d18 16≈ pi

Кодировки qNaN и sNaN не полностью определены в IEEE 754 и зависят от процессор. Большинство процессоров, таких как семейство x86 и семейство процессоров ARM, используют самый старший бит поля значимости для указания тихого NaN; это то, что рекомендуется IEEE 754. Процессоры PA-RISC используют бит для указания NaN сигнализации.

По умолчанию / 3 округляется в меньшую сторону, а не в большую, как одинарной точности, из-за нечетного количества бит в мантиссе.

Более подробно:

Учитывая шестнадцатеричное представление 3FD5 5555 5555 5555 16, Sign = 0 Exponent = 3FD 16 = 1021 Exponent Bias = 1023 (постоянное значение; см. Выше) Дробь = 5 5555 5555 5555 16 Значение = 2 × 1. Дробь - обратите внимание, что дробь не должна быть преобразована в десятичную здесь = 2 × (15 5555 5555 5555 16 × 2) = 2 × 15 5555 5555 5555 16 = 0,333333333333333314829616256247390992939472198486328125 ≈ 1/3

Скорость выполнения с арифметикой двойной точности

Использование двойной точности Переменные с плавающей запятой и математические функции (например, sin, cos, atan2, log, exp и sqrt) работают медленнее, чем работа с их аналогами с одинарной точностью. Одной из областей вычислений, где это является особой проблемой, является параллельный код, работающий на графических процессорах. Например, при использовании платформы NVIDIA CUDA вычисления с двойной точностью занимают, в зависимости от оборудования, примерно от 2 до 32 раз дольше, чем те, которые выполняются с использованием <150.>одинарная точность.

Реализации

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

C и C ++

C и C ++ предлагают широкий спектр арифметических типов. Стандарты не требуют двойной точности (за исключением дополнительного приложения F к C99, охватывающего арифметику IEEE 754), но в большинстве систем тип doubleсоответствует двойной точности. Однако на 32-битных x86 с расширенной точностью по умолчанию некоторые компиляторы могут не соответствовать стандарту C и / или арифметика может страдать от двойного округления.

Fortran

Fortran предоставляет несколько целочисленных и вещественные типы, а 64-битный тип real64, доступный через внутренний модуль Фортрана iso_fortran_env, соответствует двойной точности.

Common Lisp

Common Lisp предоставляет типы SHORT-FLOAT, SINGLE-FLOAT, DOUBLE-FLOAT и LONG-FLOAT. Большинство реализаций предоставляют SINGLE-FLOAT и DOUBLE-FLOAT с соответствующими синонимами для других типов. Common Lisp предоставляет исключения для перехвата недополнения и переполнения с плавающей запятой, а также неточное исключение с плавающей запятой согласно IEEE 754. В стандарте ANSI не описываются бесконечности и NaN, однако некоторые реализации предоставляют их как расширения.

Java

На Java до версии 1.2 каждая реализация должна быть совместима с IEEE 754. Версия 1.2 позволила реализациям повысить точность промежуточных вычислений для таких платформ, как x87. Таким образом, был введен модификатор strictfp для обеспечения строгих вычислений IEEE 754.

JavaScript

В соответствии со стандартом ECMAScript вся арифметика в JavaScript должна выполняться с использованием арифметических операций с плавающей запятой двойной точности.

См. Также

IEEE 754, стандарт IEEE для арифметики с плавающей запятой

Примечания и ссылки