Формат представления чисел с плавающей запятой
Пример №1 . Представить число 133,54 в форме числа с плавающей точкой.
Решение. Представим число 133.54 в нормализованном экспоненциальном виде:
1.3354*10 2 = 1.3354*exp10 2
Число 1.3354*exp10 2 состоит из двух частей: мантиссы M=1.3354 и экспоненты exp10=2
Если мантисса находится в диапазоне 1 ≤ M 3 Пример №2 . Представить двоичное число 101.102 в нормализованном виде, записать в 32-битом стандарте IEEE754.
Решение.
Представление двоичного числа с плавающей точкой в экспоненциальном нормализованном виде.
Сдвинем число на 2 разрядов вправо. В результате мы получили основные составляющие экспоненциального нормализованного двоичного числа:
Мантисса M=1.011
Экспонента exp2=2
Преобразование двоичного нормализованного числа в 32 битный формат IEEE 754.
Первый бит отводится для обозначения знака числа. Поскольку число положительное, то первый бит равен 0
Следующие 8 бит (с 2-го по 9-й) отведены под экспоненту.
Для определения знака экспоненты, чтобы не вводить ещё один бит знака, добавляют смещение к экспоненте в половину байта +127. Таким образом, наша экспонента: 2 + 127 = 129
Переведем экспоненту в двоичное представление.
Оставшиеся 23 бита отводят для мантиссы. У нормализованной двоичной мантиссы первый бит всегда равен 1, так как число лежит в диапазоне 1 ≤ M 22 *0 + 2 21 *1 + 2 20 *1 + 2 19 *0 + 2 18 *0 + 2 17 *0 + 2 16 *0 + 2 15 *0 + 2 14 *0 + 2 13 *0 + 2 12 *0 + 2 11 *0 + 2 10 *0 + 2 9 *0 + 2 8 *0 + 2 7 *0 + 2 6 *0 + 2 5 *0 + 2 4 *0 + 2 3 *0 + 2 2 *0 + 2 1 *0 + 2 0 *0 = 0 + 2097152 + 1048576 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 = 3145728
В десятичном коде мантисса выражается числом 3145728
В результате число 101.10 представленное в IEEE 754 c одинарной точностью равно 01000000101100000000000000000000.
Переведем в шестнадцатеричное представление.
Разделим исходный код на группы по 4 разряда.
010000001011000000000000000000002 = 0100 0000 1011 0000 0000 0000 0000 0000 2
Получаем число:
0100 0000 1011 0000 0000 0000 0000 0000 2 = 40B0000016
- Задать вопрос или оставить комментарий
- Помощь в решении
- Поиск
- Поддержать проект
Разбираемся в числах с плавающей точкой (часть 0)
Здравствуйте, хабровчане. Я давно увлекаюсь темой регистров с плавающей точкой. Меня всегда волновало то, как происходит вывод на экран и т.д. Помню, давным-давно в универе реализовывал свой класс чисел с плавающей точкой, состоящих из 512 бит. Единственное, что я не мог никак реализовать — это вывод на экран.
Как только у меня появилось свободное время, я взялся за старое. Завел себе тетрадку и пошло-поехало. Хотелось додуматься до всего самому, лишь иногда заглядывая в стандарт IEEE 754.
И вот что из всего этого вышло. Интересующихся прошу под кат.
Чтобы освоить эту статью, надо знать следующее: что такое бит, двоичная система, арифметика на уровне знания отрицательных степеней. В статье не будут затронуты инженерные подробности реализации на уровне процессора а также нормализованные и денормализованные числа. Больший упор сделан на перевод числа в двоичную форму и наоборот, а также объяснение того, как вообще хранятся числа с плавающей точкой в виде битов.
Числа с плавающей точкой — очень мощный инструмент, которым надо уметь правильно пользоваться. Они не столь банальны, как целочисленные регистры, но и не столь сложны, если в них грамотно и потихоньку вникнуть.
В сегодняшней статье для примера я буду использовать 32-битные регистры. Числа с двойной точностью (64-битные) работают абсолютно по той же логике.
Сначала поговорим о том, как хранятся числа с плавающей точкой. Старший 31 бит у нас знаковый. Единичка значит, что число отрицательное, а ноль, соответственно наоборот. Далее идут 8 бит экспоненты. Эти 8 битов представляют из себя обычное беззнаковое число. И в самом конце идут 23 бита мантиссы. Для удобства будем обозначать знак как S, экспоненту как E, а мантиссу, как ни странно, M.
Получаем общую формулу
У мантиссы принято считать один неявный единичный бит. То есть мантисса будет представлять из себя 24 бита, но так как старший 23-й бит всегда единица, то его можно не записывать. Таким образом это «ограничение» будет давать нам единственность представления любого числа.
Мантисса из себя представляет обычное двоичное число, но в отличие от целых чисел, старший бит это 2^0 степени и далее по убыванию степеней. Вот тут и пригождается экспонента. В зависимости от ее значения, степень двойки старшего бита увеличивается либо уменьшается. Вот и вся гениальность этой задумки.
Давайте попробуем показать это на наглядном примере:
Представим число 3.625 в двоичном виде. Поначалу разобьем это число на степени двойки.
Степень старшей двойки равна единице. E – 127 = 1. E = 128.
0 1000000 11010000000000000000000
Вот и все наше число.
Попробуем также и в обратную сторону. Пусть у нас есть 32 бита, произвольные 32 бита.
0 10000100 (1)11011100101000000000000
В скобочках указан тот самый неявный старший бит.
Сначала вычислим экспоненту. E = 132. Соответственно степень старшей двойки будет равна 5. Итого имеем следующее число:
Нетрудно догадаться, что мы можем хранить всего лишь диапазон из 24-х степеней двойки. Соответственно, если два числа отличаются в экспоненте на больше чем 24, то при сложении число остается равным большему среди них.
Для удобной конвертации я накидал небольшую программу на языке C.
#include union IntFloat < unsigned int integerValue; float floatValue; >; void printBits(unsigned int x) < int i; for (i = 31; i >= 0; i--) < if ((x & ((unsigned int)1 else < printf("0"); >if (i == 31) < printf(" "); >if (i == 23) < printf(" "); >> printf("\n"); > int main() Шагом сетки является минимальная разницу между двумя соседними числами с плавающей точкой. Если представить последовательность битов такого числа как обычное целое число, то соседнее число с плавающей точкой будет отличаться в битах как целое число на единицу.
Можно выразиться иначе. Два соседних числа с плавающей точкой будут отличаться на 2 ^ (E — 127 — 23). То есть на разницу, равную значению младшего бита.
В качестве доказательства можете поменять main в коде и скомпилировать еще раз.
union IntFloat b0, b1, b2; b0.floatValue = 59.578125F; b1.integerValue = b0.integerValue + 1; b2.floatValue = b1.floatValue - b0.floatValue; printBits(b0.integerValue); printBits(b1.integerValue); printBits(b2.integerValue); printf("%f\n", b0.floatValue); printf("%f\n", b1.floatValue); printf("%f\n", b2.floatValue); short exp1 = 0b10000100; short exp2 =0b01101101; /* Крайний случай, когда вся мантиса состоит из единиц */ b0.integerValue = 0b01000010011111111111111111111111; b1.integerValue = b0.integerValue + 1; b2.floatValue = b1.floatValue - b0.floatValue; printBits(b0.integerValue); printBits(b1.integerValue); printBits(b2.integerValue); printf("%f\n", b0.floatValue); printf("%f\n", b1.floatValue); printf("%f\n", b2.floatValue); /* Значения экспонент */ printf("%d %d\n", exp1, exp2); Думаю на сегодня можно закругляться, а то получается слишком длинно. В следующий раз буду писать о сложении чисел с плавающей точкой и потере точности при округлении.
P.S.: Я понимаю, что я не затронул тему денормализованных чисел и т.д. Просто не хотелось очень сильно грузить статью, да и эту информацию можно легко найти в стандарте IEEE 754 практически в самом начале.
Представление вещественных чисел
Вещественные числа обычно представляются в виде чисел с плавающей запятой. Числа с плавающей запятой — один из возможных способов представления действительных чисел, который является компромиссом между точностью и диапазоном принимаемых значений, его можно считать аналогом экспоненциальной записи чисел, но только в памяти компьютера.
Число с плавающей запятой состоит из набора отдельных двоичных разрядов, условно разделенных на так называемые знак (англ. sign), порядок (англ. exponent) и мантиссу (англ. mantis). В наиболее распространённом формате (стандарт IEEE 754) число с плавающей запятой представляется в виде набора битов, часть из которых кодирует собой мантиссу числа, другая часть — показатель степени, и ещё один бит используется для указания знака числа ( [math]0[/math] — если число положительное, [math]1[/math] — если число отрицательное). При этом порядок записывается как целое число в коде со сдвигом, а мантисса — в нормализованном виде, своей дробной частью в двоичной системе счисления. Вот пример такого числа из [math]16[/math] двоичных разрядов:
| Знак | |||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Порядок | Мантисса | ||||||||||||||
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 14 | 10 | 9 | 0 | ||||||||||||
Знак — один бит, указывающий знак всего числа с плавающей точкой. Порядок и мантисса — целые числа, которые вместе со знаком дают представление числа с плавающей запятой в следующем виде:
[math](-1)^S \times M \times B^E[/math] , где [math]S[/math] — знак, [math]B[/math] — основание, [math]E[/math] — порядок, а [math]M[/math] — мантисса. Десятичное число, записываемое как [math] ReE[/math] , где [math]R[/math] — число в полуинтервале [math][1; 10)[/math] , [math]E[/math] — степень, в которой стоит множитель [math]10[/math] ; в нормализированной форме модуль [math]R[/math] будет являться мантиссой, а [math]E[/math] — порядком, а [math]S[/math] будет равно [math]1[/math] тогда и только тогда, когда [math]R[/math] принимает отрицательное значение. Например, в числе [math]-2435e9[/math]
- [math]S[/math] [math]=[/math] [math]1[/math]
- [math]B[/math] [math]=[/math] [math]10[/math]
- [math]M[/math] [math]=[/math] [math]2435[/math]
- [math]E[/math] [math]=[/math] [math]9[/math]
Порядок также иногда называют экспонентой или просто показателем степени.
При этом лишь некоторые из вещественных чисел могут быть представлены в памяти компьютера точным значением, в то время как остальные числа представляются приближёнными значениями.
Более простым вариантом представления вещественных чисел является вариант с фиксированной точкой, когда целая и вещественная части хранятся отдельно. Например, на целую часть отводится всегда [math]X[/math] бит и на дробную отводится всегда [math]Y[/math] бит. Такой способ в архитектурах процессоров не присутствует. Отдаётся предпочтение числам с плавающей запятой, как компромиссу между диапазоном допустимых значений и точностью.
Нормальная и нормализованная форма
Нормальной формой (англ. normal form) числа с плавающей запятой называется такая форма, в которой мантисса (без учёта знака) в десятичной системе находится на полуинтервале [math][0; 1)[/math] . Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, [math]00001[/math] можно записать в 4 формах — [math]00001 \times 10[/math] [math]0[/math] , [math]0001 \times 10[/math] [math]−1[/math] , [math]001 \times 10[/math] [math]−2[/math] , [math]01 \times 10[/math] [math]−3[/math] ), поэтому распространена также другая форма записи — нормализованная (англ. normalized), в которой мантисса десятичного числа принимает значения от [math]1[/math] (включительно) до [math]10[/math] (не включительно), а мантисса двоичного числа принимает значения от [math]1[/math] (включительно) до [math]2[/math] (не включительно). То есть в мантиссе слева от запятой до применения порядка находится ровно один знак. В такой форме любое число (кроме [math]0[/math] ) записывается единственным образом. Ноль же представить таким образом невозможно, поэтому стандарт предусматривает специальную последовательность битов для задания числа [math]0[/math] (а заодно и некоторых других полезных чисел, таких как [math]-\infty[/math] и [math]+\infty[/math] ). Так как старший двоичный разряд (целая часть) мантиссы вещественного числа в нормализованном виде всегда равен « [math]1[/math] », то его можно не записывать, сэкономив таким образом один бит, что и используется в стандарте IEEE 754. В позиционных системах счисления с основанием большим, чем [math]2[/math] (в троичной, четверичной и др.), этого замечательного свойства нет (ведь целая часть там может быть не только единицей).
Типы чисел с плавающей точкой (по IEEE 754)
Число половинной точности (Binary16, Half precision)
Число́ полови́нной то́чности — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — [math]16[/math] бит или [math]2[/math] байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.
| Знак | ||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Порядок | Мантисса | |||||||||||||||
| 0 | 0 | 0 | 0 | 0 | 0 | 1, | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 14 | 10 | 9 | 0 | |||||||||||||
Порядок записан со сдвигом [math]-15[/math] . То есть чтобы получить актуально значение порядка нужно вычесть из него сдвиг. Сдвиг можно получить по формуле [math]2^-1[/math] , где [math]b[/math] — число бит, отведенное на хранение порядка (в случае числа половинной точности [math]b=5[/math] ).
Ограничения точности
- Целые от нуля до [math]2048[/math] передаются как есть.
- Целые от [math]2049[/math] до [math]4096[/math] округляются к ближайшему чётному целому.
- Целые от [math]4097[/math] до [math]8192[/math] округляются до ближайшего целого, делящегося нацело на четыре.
- Целые от [math]8193[/math] до [math]16384[/math] округляются до ближайшего целого, делящегося на восемь.
- Целые от [math]16385[/math] до [math]32768[/math] округляются до ближайшего целого, делящегося на шестнадцать.
- Целые от [math]32769[/math] до [math]65535[/math] округляются до ближайшего целого, делящегося на тридцать два.
Число одинарной точности (Binary32, Single precision, float)
Число́ одина́рной то́чности — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — [math]32[/math] бита или [math]4[/math] байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.
| Знак | ||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Порядок (8 бит) | Мантисса (23+1 бита) | |||||||||||||||||||||||||||||||
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1, | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 30 | 23 | 22 | 0 | |||||||||||||||||||||||||||||
Порядок записан со сдвигом [math]-127[/math] .
Число двойной точности (Binary64, Double precision, double)
Число́ двойно́й то́чности — компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — [math]64[/math] бита или [math]8[/math] байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.
| Знак | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Порядок (11 бит) | Мантисса (52+1 бит) | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1, | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 62 | 52 | 51 | 0 | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Порядок записан со сдвигом [math]-1023[/math] .
Число четверной точности (Binary128, Quadruple precision)
Число́ четверно́й то́чности — компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — [math]128[/math] бит или [math]16[/math] байт). Используется в случае необходимости крайне высокой точности.
| Знак | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Порядок (15 бит) | Мантисса (112+1 бит) | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1, | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 126 | 112 | 111 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Мантисса (112+1 бит) | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 0 | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Порядок записан со сдвигом [math]-16383[/math] .
Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки. Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью). В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.
Диапазон значений чисел с плавающей запятой
Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, «не число», получается как результат операций типа деления нуля на ноль) и [math]\pm\infty[/math] .
Данная таблица только лишь примерно указывает границы допустимых значений, без учета возрастающей погрешности с ростом абсолютного значения и существования денормализованных чисел.
| Название в IEEE 754 | Название типа переменной в Си | Диапазон значений | Бит в мантиссе | Бит на переменную |
|---|---|---|---|---|
| Half precision | — | 6,10×10 -5 ..65504 | 11 | 16 |
| Single presicion | float | -3,4×10 38 ..3,4×10 38 | 23 | 32 |
| Double precision | double | -1,7×10 308 ..1,7×10 308 | 53 | 64 |
| Extended precision | На некоторых архитектурах (например в сопроцессоре Intel) long double | -3,4×10 4932 ..3,4×10 4932 | 65 | 80 |
Особые значения чисел с плавающей точкой
Ноль (со знаком)
Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль. Поэтому для его представления зарезервированы специальные значения мантиссы и порядка — число считается нулём, если все его биты, кроме знакового, равны нулю. При этом в зависимости от значения бита знака ноль может быть как положительным, так и отрицательным.
| Знак | |||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Порядок | Мантисса | ||||||||||||||||
| 0 /1 | 0 | 0 | 0 | 0 | 0 | 1, | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | = [math]\pm0[/math] |
| 14 | 10 | 9 | 0 | ||||||||||||||
Арифметика нуля со знаком
Арифметика отрицательного нуля аналогична таковой для любого отрицательного числа и понятна интуитивно. Вот несколько примеров:
- [math]\frac< \left| x \right| >= -0\,\![/math] (если [math]x\ne0[/math] )
- [math](-0) \cdot (-0) = +0\,\![/math]
- [math]\left| x \right| \cdot (-0) = -0\,\![/math]
- [math]x + (\pm 0) = x\,\![/math]
- [math](-0) + (-0) = -0\,\![/math]
- [math](+0) + (+0) = +0\,\![/math]
- [math]\frac<-\infty>= +0\,\![/math]
- [math]\frac<\left|x\right|>= -\infty\,\![/math] (если [math]x\ne0[/math] )
Неопределенность (NaN)
NaN — это аббревиатура от фразы «not a number«. NaN является результатом арифметических операций, если во время их выполнения произошла ошибка (примеры см. ниже). В IEEE 754 NaN представлен как число, в котором все двоичные разряды порядка — единицы, а мантисса не нулевая.
| Знак | |||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Порядок | Мантисса | ||||||||||||||||
| 0 /1 | 1 | 1 | 1 | 1 | 1 | 1, | 0 /1 | 0 /1 | 0 /1 | 0 /1 | 0 /1 | 0 /1 | 0 /1 | 0 /1 | 0 /1 | 0 /1 | = [math]NaN[/math] |
| 14 | 10 | 9 | 0 | ||||||||||||||
Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.
Как можно получить NaN?
- [math]\infty+(-\infty)= NaN[/math]
- [math]0\times\infty= NaN[/math]
- [math]\frac<\pm0><\pm0>= NaN[/math]
- [math]\frac<\pm\infty><\pm\infty>= NaN[/math]
- [math]\sqrt = NaN[/math] , где [math]x\lt 0[/math]
Есть и другие способы получения NaN, подробности можно найти по ссылкам в соответствующем разделе.
По определению NaN ≠ NaN, поэтому, для проверки значения переменной нужно просто сравнить ее с собой.
Бесконечности
В число с плавающей запятой можно записать значение [math]+\infty[/math] или [math]-\infty[/math] . Как и нули со знаком, бесконечности позволяют получить хотя бы близкий к правильному результат вычисления в случае переполнения. Согласно стандарту IEEE 754 число с плавающей запятой считается равным бесконечности, если все двоичные разряды его порядка — единицы, а мантисса равна нулю. Знак бесконечности определяется знаковым битом числа.
| Знак | |||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Порядок | Мантисса | ||||||||||||||||
| 0 /1 | 1 | 1 | 1 | 1 | 1 | 1, | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | = [math]\pm\infty[/math] |
| 14 | 10 | 9 | 0 | ||||||||||||||
Получить бесконечность можно при переполнении и при делении ненулевого числа на ноль. При этом [math] \frac [/math] [math]= \begin +\infty,&\text\\ NaN,&\text\\ -\infty,&\text \end [/math]
Денормализованные числа
Денормализованные числа (англ. denormalized/subnormal numbers) — это способ увеличить количество представимых числом с плавающей запятой значений около нуля, дабы повысить точность вычислений. Каждое значение денормализованного числа меньше самого маленького нормализованного («обычного») значения числа с плавающей запятой. Согласно стандарту, если порядок равен своему минимальному значению (все его биты — нули, а истинное значение порядка равно его сдвигу) и все биты мантиссы равны нулю, то это [math]\pm0[/math] . Если же мантисса не равна нулю, то это число с порядком, на единицу большим минимального (все биты порядка, кроме младшего — нули) и данной мантиссой, целая часть которой считается равной нулю, а не единице.
То есть число с плавающей запятой, при учете вышесказанного, можно задать следующим образом:
- [math](-1)^s\times1,M\times2^E[/math] , если [math]E_ \le E \le E_[/math] (нормализованное число)
- [math](-1)^s\times0,M\times2^
[/math] , если [math]E=E_-1[/math] (денормализованное число)
Где [math]s[/math] — бит знака, [math]M[/math] — последовательность битов мантиссы, [math]E[/math] — значение порядка (с учетом сдвига), [math]E_[/math] — минимальное значение порядка, используемое для записи чисел (1 — сдвиг) , [math]E_-1[/math] — минимальное значение порядка, которое он в принципе может принять (все биты нули, 0 — сдвиг).
Хоть денормализованные числа и позволяют бороться с погрешностями и обрабатывать очень маленькие значения, за эти возможности приходится дорого платить. Ввиду сложности денормализованные числа крайне редко реализуют на аппаратном уровне — вместо этого используются программные реализации, работающие значительно медленнее.
В современных процессорах обработка денормализованных чисел происходит в десятки раз медленнее, чем обработка нормализованных чисел. Ниже приведена часть таблицы из статьи Isaac Dooley, Laxmikant Kale «Quantifying the Interference Caused by Subnormal Floating-Point Values» [1]
| Производитель | Процессор | Замедление (разы) |
|---|---|---|
| IBM | PowerPC 970 | 2,4 |
| AMD | Athlon | 6,0 |
| Intel | Pentium 3 | 15,8 |
| AMD | Athlon 64 | 21,4 |
| AMD | Opteron64 | 23,8 |
| Intel | Core Duo | 44,2 |
| Intel | P4 Xeon | 97,9 |
| Intel | Pentium 4 | 131,0 |
| Intel | Itanium 2 | 183,2 |
| Sun | UltraSPARC IV | 520,0 |
В таблице приведены наихудшие результаты тестирования среди всех использованных компиляторов (gcc, icc, xlc) со всеми доступными флагами оптимизации. Исследователи утверждают, что различие среднего случая с худшим незначительно.
Поскольку в стандартных форматах (одинарной и двойной точности) денормализованные числа получаются действительно очень маленькими и практически никак не влияют на результат некоторых вычислений (при этом заметно замедляя их скорость), то иногда они просто игнорируются. При этом используются два простых механизма, получивших называние Flush-to-zero (FTZ) и Denormals-are-zero (DAZ). Первый механизм заставляет операции возвращать ноль, как только становится ясно, что результат будет денормализованным. Второй механизм заставляет операции рассматривать поступающие на вход денормализованные числа как нули.
Ярким примером подобного «отсечения» денормализованных чисел могут послужить видеокарты, в которых резкое падение скорости вычислений в сотню раз недопустимо. Так же, например, в областях, связанных с обработкой звука, нет нужды в очень маленьких числах, поскольку они представляют столь тихий звук, что его не способно воспринять человеческое ухо.
В версии стандарта IEEE 754-2008 денормализованные числа (denormal или denormalized numbers) были переименованы в subnormal numbers, то есть в числа, меньшие «нормальных». Поэтому их иногда еще называют «субнормальными«.
Действия с числами с плавающей запятой
Умножение и деление
Самыми простыми для восприятия арифметическими операциями над числами с плавающей запятой являются умножение и деление. Для того, чтобы умножить два вещественных числа в нормализованной форме необходимо перемножить их мантиссы, сложить порядки, округлить и нормализовать полученное число.
Соответственно, чтобы произвести деление нужно разделить мантиссу делимого на мантиссу делителя и вычесть из порядка делимого порядок делителя. Затем точно так же округлить мантиссу результата и привести его к нормализованной форме.
Сложение и вычитание
Идея метода сложения и вычитания чисел с плавающей точкой заключается в приведении их к одному порядку. Сначала выбирается оптимальный порядок, затем мантиссы обоих чисел представляются в соответствии с новым порядком, затем над ними производится сложение/вычитание, мантисса результата округляется и, если нужно, результат приводится к нормализированной форме. Пример:
Выполним сложение чисел с плавающей точкой и смещенным порядком в 32-х разрядном формате и . Переведем в машинный вид. Для этого сначала переведем его в двоичную систему счисления.
Нормализуем полученное двоичное число по правилам машинной арифметики.
Найдем смещенный порядок. Так как в условии говорится о 32-разрядном представлении, то смещение порядка равно .
Число отрицательное, следовательно, в бите знака будет стоять единица.
Итак, первое число в машинном 32-разрядном представлении с плавающей точкой будет иметь вид: 10000111 (жирным шрифтом выделен порядок числа, длина мантиссы — 23 бита).
Переведем второе число в машинный вид, совершая те же действия.
= ,. . В качестве мантиссы будут сохранены первые бита после запятой т.е. . Очевидно, что порядок со смещением у второго числа будет таким же, как и у первого.
Второе число положительное, следовательно, бит знака будет содержать ноль.
Итак в машинном 32-разрядном представлении второе число будет иметь вид:
10000111 Далее в арифметических операциях будет использоваться число ,=, а не = видимо для упрощения(хотя это не совсем корректно).
Порядки у слагаемых равны, поэтому пропускаем шаг выравнивания порядков и проводим вычитание мантисс по правилам двоичной арифметики. В компьютере этим занимается арифметический сопроцессор, встроенный в центральный процессор машины.
,
Приводим полученный результат к машинному виду. Для этого мы должны внести поправку в порядок — уменьшить его на единицу. Знак результата — положительный, следовательно, бит знака содержит ноль.
10000110
Проверим правильность наших вычислений. Переведем результат в десятичное представление.
Найдем реальный порядок результата, вычтя из него значение смещения .
Следовательно, число результата будет иметь вид: ,
Результат наших вычислений верен, так как - .
Алгоритм получения представления вещественного числа в памяти ЭВМ
Покажем преобразование действительного числа для представления его в памяти ЭВМ на примере величины типа Double.
Как видно из таблицы, величина этого типа занимает в памяти [math]8[/math] байт. На рисунке ниже показано, как здесь представлены поля мантиссы и порядка (нумерация битов осуществляется справа налево):
| Знак | Смещённый порядок | Мантисса |
|---|---|---|
| 63 | 62..52 | 51..0 |
Можно заметить, что старший бит, отведенный под мантиссу, имеет номер [math]51[/math] , т.е. мантисса занимает младшие [math]52[/math] бита. Черта указывает здесь на положение двоичной запятой. Перед запятой должен стоять бит целой части мантиссы, но поскольку она всегда равна [math]1[/math] , здесь данный бит не требуется и соответствующий разряд отсутствует в памяти (но он подразумевается). Значение порядка хранится здесь не как целое число, представленное в дополнительном коде. Для упрощения вычислений и сравнения действительных чисел значение порядка в ЭВМ хранится в виде смещенного числа, т.е. к настоящему значению порядка перед записью его в память прибавляется смещение. Смещение выбирается так, чтобы минимальному значению порядка соответствовал нуль. Например, для типа Double порядок занимает [math]11[/math] бит и имеет диапазон от [math]2[/math] [math]-1023[/math] до [math]2[/math] [math]1023[/math] , поэтому смещение равно [math]1023[/math] ( [math]10[/math] ) [math]=[/math] [math]1111111111[/math] ( [math]2[/math] ). Наконец, бит с номером [math]63[/math] указывает на знак числа.
Таким образом, из вышесказанного вытекает следующий алгоритм для получения представления действительного числа в памяти ЭВМ:
- перевести модуль данного числа в двоичную систему счисления;
- нормализовать двоичное число, т.е. записать в виде M [math] \times [/math] 2 p , где M — мантисса (ее целая часть равна [math]1[/math] ( [math]2[/math] )) и p — порядок, записанный в десятичной системе счисления;
- прибавить к порядку смещение и перевести смещенный порядок в двоичную систему счисления;
- учитывая знак заданного числа (0 — положительное; 1 — отрицательное), выписать его представление в памяти ЭВМ.
Пример. Запишем код числа [math]-312[/math] , [math]3125[/math] .
- Двоичная запись модуля этого числа имеет вид [math]1001110000101[/math] .
- Имеем [math]1001110000101[/math] [math]=[/math] [math]1001110000101[/math] [math]\times[/math] [math]2[/math] [math]8[/math] .
- Получаем смещенный порядок [math]8[/math] [math]+[/math] [math]1023[/math] [math]=[/math] [math]1031[/math] . Далее имеем [math]1031[/math] ( [math]10[/math] ) [math]=[/math] [math]10000000111[/math] ( [math]2[/math] ).
- Окончательно
| 1 | 10000000111 | 0011100001010000000000000000000000000000000000000000 |
| 63 | 62..52 | 51..0 |
Очевидно, что более компактно полученный код стоит записать следующим образом: C073850000000000(16).
Другой пример иллюстрирует обратный переход от кода действительного числа к самому числу.
Пример. Пусть дан код 3FEC600000000000(16) или
| 0 | 01111111110 | 1100011000000000000000000000000000000000000000000000 |
| 63 | 62..52 | 51..0 |
Как перевести дробное десятичное число в двоичное. С плавающей запятой.
Перевод из десятичной в произвольную позиционную систему счисления
Целая часть
1. Последовательно делить целую часть десятичного числа на основание, пока десятичное число не станет равно нулю.
2. Полученные при делении остатки являются цифрами нужного числа. Число в новой системе записывают, начиная с последнего остатка.
Дробная часть
1. Дробную часть десятичного числа умножаем на основание системы, в которую требуется перевести. Отделяем целую часть. Продолжаем умножать дробную часть на основание новой системы, пока она не станет равной 0.
2. Число в новой системе записывают, начиная с последнего остатка, как при целой части.
Пример
44(10) переведём в двоичную систему
44 делим на 2. частное 22, остаток 0
22 делим на 2. частное 11, остаток 0
11 делим на 2. частное 5, остаток 1
5 делим на 2. частное 2, остаток 1
2 делим на 2. частное 1, остаток 0
1 делим на 2. частное 0, остаток 1
Частное равно нулю, деление закончено. Теперь записав все остатки снизу вверх получим число 101100(2)
Для перевода дробной части числа в другие системы счисления нужно обратить целую часть в нуль и начать умножение получившегося числа на основание той системы, в которую нужно перевести. Если в результате умножения будут снова появляться целые части, их нужно повторно обращать в нуль, предварительно запомнив (записав) значение получившейся целой части. Операция заканчивается, когда дробная часть полностью обратится в нуль. Ниже приводится пример перевода числа 103,625(10) в двоичную систему счисления.
Переводим целую часть по правилам, описанным выше, получаем 103(10) = 1100111(2).
0,625 умножаем на 2. Дробная часть 0,250. Целая часть 1.
0,250 умножаем на 2. Дробная часть 0,500. Целая часть 0.
0,500 умножаем на 2. Дробная часть 0,000. Целая часть 1.
Итак, сверху вниз получаем число 101(2)
103,625(10) = 1100111,101(2)
Точно также осуществляется перевод в системы счисления с любым основанием.
Сразу нужно отметить, что этот пример специально подобран, в общем случае очень редко удаётся завершить перевод дробной части числа из десятичной системы в другие системы счисления, а потому, в подавляющем большинстве случаев, перевод можно осуществить с какой либо долей погрешности. Чем больше знаков после запятой — тем точнее приближение результата перевода к истине. В этих словах легко убедиться, если попытаться, например, перевести в двоичный код число 0,626.
ps: насчет плавающей запятой тоже просто
Формат чисел с плавающей запятой базируется на экспоненциальной форме записи, в которой может быть представлено любое число. Так число А может быть представлено в виде: A=m*n^q, где m — мантисса числа; q — основание системы счисления;
n — порядок числа.
Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, 0,0001 можно записать в 4 формах — 0,0001×10^0, 0,001×10^−1, 0,01×10^−2, 0,1×10^−3), поэтому распространена (особенно в информатике) также другая форма записи — нормализованная, в которой мантисса десятичного числа принимает значения от 1 (включительно) до 10 (не включительно) , а мантисса двоичного числа принимает значения от 1 (включительно) до 2 (не включительно) . В такой форме любое число (кроме 0) записывается единственным образом. Недостаток заключается в том, что в таком виде невозможно представить 0, поэтому представление чисел в информатике предусматривает специальный признак (бит) для числа 0.
Это означает, что мантисса должна быть правильной дробью и иметь после запятой цифру, отличную от нуля.
Преобразуем десятичное число 555,55, записанное в естественной форме, в экспоненциальную форму с нормализованной мантиссой:
555,55 = 0,55555 × 10³ .
Здесь нормализованная мантисса: m = 0,55555, порядок: n = 3.
http://www.5byte.ru/11/0008.php
Источник: ru.wikipedia.org/wiki/Позиционная_система_счисления
Остальные ответы
Давай число.
Формат хранения вещественных чисел в разных языках разный, но во всяком случае такого
маразма как дробные двоичные числа на самом деле в природе не существует. Для каждого такого числа вычисляется мантисса и экспонента, и они сжимаются определенным образом.
В уме или на бумажке перевести вещественное число в двоичную форму не получится.
Требуется перевести дробное десятичное число 206,116 в дробное двоичное число.
Перевод целой части дает 206=11001110(для этого мы делим 206 на два и записываем остатки от деления) , затем дробную часть умножаем на основание 2, до тех пор, пока дробная часть не будет равна нулю, занося целые части произведения в разряды после запятой искомого дробного двоичного числа:
.116 • 2 = 0.232
.232 • 2 = 0.464
.464 • 2 = 0.928
.928 • 2 = 1.856
.856 • 2 = 1.712
.712 • 2 = 1.424
.424 • 2 = 0.848
.848 • 2 = 1.696
.696 • 2 = 1.392
.784 • 2 = 0.784
Получим: 206=11001110,0001110110
Дано дробное число 11101001,011 в двоичной системе счисления. Найдите его нормализованную мантиссу и порядок в двоичной системе счисления. Напишите пример ненормализованной мантиссы для данного числа в двоичной системе счисления.
44(10) переведём в двоичную систему
44 делим на 2. частное 22, остаток 0
22 делим на 2. частное 11, остаток 0
11 делим на 2. частное 5, остаток 1
5 делим на 2. частное 2, остаток 1
2 делим на 2. частное 1, остаток 0
1 делим на 2. частное 0, остаток 1
Частное равно нулю, деление закончено. Теперь записав все остатки снизу вверх получим число 101100(2)