Викиконспекты - Вклад участника [ru]

Персистентный стек

2015-06-06T21:06:01Z

Паршуков Кирилл: /* Алгоритм */

== Алгоритм ==

=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
'''struct''' '''Query''':
'''T''' value
'''uint''' prev

У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Query''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===
Будем использовать узел, у которого будет значение и ссылка на прошлую версию стека. При этом сам узел - это версия стека.
'''struct''' '''Node''':
'''T''' value
'''Node''' prev
Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 
Сам персистентный стек будет обозначатся <tex>s</tex>. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''T''' val = i.value
i = i.prev
'''return''' pair(val, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Применение ==
Используя персистентый стек, можно реализовать легко перстистентную очередь (если вспомнить её реализацию на двух стеках). 
См. [[Персистентная очередь]]

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T21:01:38Z

Паршуков Кирилл: /* Реализация на списке */

== Алгоритм ==
Будем использовать узел, у которого будет значение и ссылка на прошлую версию стека. При этом сам узел - это версия стека.
'''struct''' '''Node''':
'''T''' value
'''Node''' prev
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 
Сам персистентный стек будет обозначатся <tex>s</tex>. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''T''' val = i.value
i = i.prev
'''return''' pair(val, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Применение ==
Используя персистентый стек, можно реализовать легко перстистентную очередь (если вспомнить её реализацию на двух стеках). 
См. [[Персистентная очередь]]

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T20:57:13Z

Паршуков Кирилл: /* Применение */

== Алгоритм ==
Будем использовать узел, у которого будет значение и ссылка на прошлую версию стека. При этом сам узел - это версия стека.
'''struct''' '''Node''':
'''T''' value
'''Node''' prev
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 
Сам персистентный стек будет обозначатся <tex>s</tex>. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Применение ==
Используя персистентый стек, можно реализовать легко перстистентную очередь (если вспомнить её реализацию на двух стеках). 
См. [[Персистентная очередь]]

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T20:45:54Z

Паршуков Кирилл: /* Применение */

== Алгоритм ==
Будем использовать узел, у которого будет значение и ссылка на прошлую версию стека. При этом сам узел - это версия стека.
'''struct''' '''Node''':
'''T''' value
'''Node''' prev
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 
Сам персистентный стек будет обозначатся <tex>s</tex>. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Применение ==
В основном используется когда нужно быстрое обращение по результатам команд добавить/удалить.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T20:43:57Z

Паршуков Кирилл: /* Алгоритм */

== Алгоритм ==
Будем использовать узел, у которого будет значение и ссылка на прошлую версию стека. При этом сам узел - это версия стека.
'''struct''' '''Node''':
'''T''' value
'''Node''' prev
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 
Сам персистентный стек будет обозначатся <tex>s</tex>. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Применение ==
Персистентный стек используется не очень часто, так как сложные задачи с ним не придумать из-за его примитивности. В основном используется когда нужно быстрое обращение по результатам команд добавить/удалить.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T20:40:15Z

Паршуков Кирилл: /* Реализация на массиве */

== Алгоритм ==
'''struct''' '''Node''':
'''T''' value // Значение в узле
'''Node''' prev // Ссылка на прошлую версию
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 
Сам персистентный стек будет обозначатся <tex>s</tex>. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Применение ==
Персистентный стек используется не очень часто, так как сложные задачи с ним не придумать из-за его примитивности. В основном используется когда нужно быстрое обращение по результатам команд добавить/удалить.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T20:35:17Z

Паршуков Кирилл: /* Пример задачи */

== Алгоритм ==
'''struct''' '''Node''':
'''T''' value // Значение в узле
'''Node''' prev // Ссылка на прошлую версию
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 
Сам персистентный стек будет обозначатся <tex>s</tex>. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Применение ==
Персистентный стек используется не очень часто, так как сложные задачи с ним не придумать из-за его примитивности. В основном используется когда нужно быстрое обращение по результатам команд добавить/удалить.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T20:20:26Z

Паршуков Кирилл: /* Реализация на списке */

== Алгоритм ==
'''struct''' '''Node''':
'''T''' value // Значение в узле
'''Node''' prev // Ссылка на прошлую версию
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 
Сам персистентный стек будет обозначатся <tex>s</tex>. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T20:19:54Z

Паршуков Кирилл: /* Реализация на списке */

== Алгоритм ==
'''struct''' '''Node''':
'''T''' value // Значение в узле
'''Node''' prev // Ссылка на прошлую версию
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 
Сам персистентный стек будет обозначатся s. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T20:17:42Z

Паршуков Кирилл: /* Реализация на списке */

== Алгоритм ==
'''struct''' '''Node''':
'''T''' value // Значение в узле
'''Node''' prev // Ссылка на прошлую версию
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T20:13:48Z

Паршуков Кирилл: /* Реализация на массиве */

== Алгоритм ==
'''struct''' '''Node''':
'''T''' value // Значение в узле
'''Node''' prev // Ссылка на прошлую версию
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Обойдёмся без массива. Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T20:13:09Z

Паршуков Кирилл: /* Алгоритм */

== Алгоритм ==
'''struct''' '''Node''':
'''T''' value // Значение в узле
'''Node''' prev // Ссылка на прошлую версию
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Обойдёмся без массива. Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T19:53:56Z

Паршуков Кирилл: /* Реализация на массиве */

== Алгоритм ==
'''struct''' '''Node''':
'''T''' value
'''Node''' prev
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)
'''return''' s[i].value

=== Реализация на списке ===

Обойдёмся без массива. Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T19:52:44Z

Паршуков Кирилл: /* Алгоритм */

== Алгоритм ==
'''struct''' '''Node''':
'''T''' value
'''Node''' prev
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>,
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)

=== Реализация на списке ===

Обойдёмся без массива. Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
s.top = k
'''return''' s

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair<T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)
'''return''' pair(i.value, s)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T19:50:28Z

Паршуков Кирилл: /* Реализация на списке */

== Алгоритм ==
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)

=== Реализация на списке ===

Обойдёмся без массива. Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 

* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>,
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
top = k

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair <T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T19:30:59Z

Паршуков Кирилл: /* Реализация на списке */

== Алгоритм ==
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)

=== Реализация на списке ===

Обойдёмся без массива. Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 

* Узел:
'''struct''' '''Node''':
'''T''' value
'''Node''' prev
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>.
'''Stack''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
top = k

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''pair <T, Stack>''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T19:28:30Z

Паршуков Кирилл:

== Алгоритм ==
=== Реализация на массиве ===
Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)

=== Реализация на списке ===

Обойдёмся без массива. Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 

* Узел:
'''struct''' '''Node''':
'''T''' value
'''Node''' prev
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>.
'''function''' push(i : '''Node''', x : '''T'''):
k.value = x
k.prev = i
top = k

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
'''T''' pop(i : '''Node'''):
'''Node''' k = i.prev
push(k.prev, k.value)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T19:10:00Z

Паршуков Кирилл: /* Альтернативная реализация */

== Эффективная реализация ==

Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)

== Альтернативная реализация ==

Обойдёмся без массива. Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>.
function push(i : Node, x : T):
k.value = x
k.prev = i
top = k

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
T pop(i : Node):
Node k = i.prev
push(k.prev, k.value)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T19:09:35Z

Паршуков Кирилл:

== Эффективная реализация ==

Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)

== Альтернативная реализация ==

Обойдёмся без массива. Будем хранить состояния в узлах. Будем возвращать пользователю информацию о текущей вершине. 
У каждого узла будет <tex>2</tex> поля: значение в вершине стека и ссылка на предыдущую версию стека. 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек узла <tex>i</tex>.
function push(i : Node, x : T):
k.value = x
k.prev = i
top = k

* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в узле <tex>i</tex> и копирует элемент, предыдущий для него.
T pop(i : Node)
Node k = i.prev
push(k.prev, k.value)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-06T18:33:23Z

Паршуков Кирилл:

== Эффективная реализация ==

Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент <tex>x</tex> в стек с номером <tex>i</tex>, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером <tex>i</tex> и копирует элемент, предыдущий для него,
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
'''Node''' k = s[i]
k = s[k.prev]
push(k.prev, k.value)

== Пример ==

Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|}

Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|}

Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|}

Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|}

Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>\mathtt{null}</tex>
|3
|5
|3
|6
|1
|<tex>\mathtt{null}</tex>
|5
|9
|-align = "center"
!prev
|<tex>\mathtt{null}</tex>
|1
|2
|1
|3
|5
|<tex>\mathtt{null}</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== Пример задачи ==
N детей по очереди лепят снеговиков. Первый ребенок слепил снеговик из одного шара радиусом R1. Каждый следующий ребенок слепил такого же снеговика, как и предыдущий, но подумав немного либо добавил шар радиусом Ri, либо разрушил верхний, уже имеющийся шар. Гарантируется, что все снеговики имеют строго положительное число шаров. Входные данные — N, информация о каждом из детей о том, разрушил ли он последний шар, либо добавил свой (тогда дается и его радиус). Далее дается набор из K чисел в пределах от 1-го до N, для каждого требуется вывести последовательность шаров в снеговике с таким номером. Ограничение на N и K — миллион.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr {{---}} Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-05T18:47:17Z

Паршуков Кирилл: /* Эффективная реализация */

Персистентный стек

2015-06-05T18:37:20Z

Паршуков Кирилл: /* Источники информации */

Персистентный стек

2015-06-05T18:36:51Z

Паршуков Кирилл: /* Пример */

Персистентный стек

2015-06-05T18:33:10Z

Паршуков Кирилл: /* Пример */

Персистентный стек

2015-06-05T18:29:30Z

Паршуков Кирилл: /* Эффективная реализация */

Персистентный стек

2015-06-05T18:19:56Z

Паршуков Кирилл: /* Источники информации */

== Эффективная реализация ==

Попробуем решить задачу эффективнее. Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет <tex>2</tex> поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент х в стек с номером i, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером i и копирует элемент, предыдущий для него.
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
T k = s[i]
k = s[k.prev]
push(k.prev, k.value)

== Пример ==

* Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>null</tex>
|-align = "center"
!prev
|<tex>null</tex>
|}

* Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>null</tex>
|3
|-align = "center"
!prev
|<tex>null</tex>
|1
|}

* Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>null</tex>
|3
|5
|-align = "center"
!prev
|<tex>null</tex>
|1
|2
|}

* Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>null</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>null</tex>
|1
|2
|1
|}

* Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>null</tex>
|3
|5
|3
|6
|1
|<tex>null</tex>
|5
|9
|-align = "center"
!prev
|<tex>null</tex>
|1
|2
|1
|3
|5
|<tex>null</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr - Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]
[[Категория: Структуры данных]]

Персистентный стек

2015-06-05T18:18:54Z

Паршуков Кирилл: /* Эффективная реализация */

Персистентный стек

2015-06-05T18:18:29Z

Паршуков Кирилл: /* Пример */

== Эффективная реализация ==

Попробуем решить задачу эффективнее. Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет 2 поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент х в стек с номером i, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером i и копирует элемент, предыдущий для него.
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
T k = s[i]
k = s[k.prev]
push(k.prev, k.value)

== Пример ==

* Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>null</tex>
|-align = "center"
!prev
|<tex>null</tex>
|}

* Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением <tex>3</tex>, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>null</tex>
|3
|-align = "center"
!prev
|<tex>null</tex>
|1
|}

* Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>null</tex>
|3
|5
|-align = "center"
!prev
|<tex>null</tex>
|1
|2
|}

* Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает <tex>5</tex> и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>null</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>null</tex>
|1
|2
|1
|}

* Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>null</tex>
|3
|5
|3
|6
|1
|<tex>null</tex>
|5
|9
|-align = "center"
!prev
|<tex>null</tex>
|1
|2
|1
|3
|5
|<tex>null</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr - Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]

Персистентный стек

2015-06-05T18:16:33Z

Паршуков Кирилл: /* Эффективная реализация */

== Эффективная реализация ==

Попробуем решить задачу эффективнее. Заведем массив запросов, модифицирующих стек. 
У каждого элемента массива будет 2 поля: значение в вершине стека и индекс предыдущей версии стека. 
Тогда операции push и pop будут иметь следующий вид: 
* <tex> \mathrm{push}(i, x)</tex> {{---}} добавляет элемент х в стек с номером i, результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''function''' push(i : '''uint''', x : '''T'''):
s.top = s.top + 1
s[s.top].value = x
s[s.top].prev = i
* <tex>\mathrm{pop}(i)</tex> {{---}} возвращает значение, хранящееся в элементе с номером i и копирует элемент, предыдущий для него.
результирующий стек будет иметь номер <tex> n + 1 </tex>.
'''T''' pop(i : '''uint'''):
T k = s[i]
k = s[k.prev]
push(k.prev, k.value)

== Пример ==

* Пусть изначально у нас есть один пустой стек. Запишем его в массив.
[[Файл:стек1.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
|-align = "center"
!value
|<tex>null</tex>
|-align = "center"
!prev
|<tex>null</tex>
|}

* Далее выполним <tex>\mathrm{push}(1, 3)</tex>. Создается новая вершина со значением 3, ссылающаяся на 1-ую, помещаем ее во 2-ую ячейку массива:
[[Файл:стек2.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
|-align = "center"
!value
|<tex>null</tex>
|3
|-align = "center"
!prev
|<tex>null</tex>
|1
|}

* Аналогично выполним <tex>\mathrm{push}(2, 5)</tex>:
[[Файл:стек3.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
|-align = "center"
!value
|<tex>null</tex>
|3
|5
|-align = "center"
!prev
|<tex>null</tex>
|1
|2
|}

* Выполним <tex>\mathrm{pop}(3)</tex>. он возвращает 5 и копирует 2-ую вершину.
[[Файл:стек4.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
|-align = "center"
!value
|<tex>null</tex>
|3
|5
|3
|-align = "center"
!prev
|<tex>null</tex>
|1
|2
|1
|}

* Так будет выглядеть массив после последовательности операций <tex>\mathrm{push}(3, 6), \mathrm{push}(5, 1), \mathrm{pop}(4), \mathrm{pop}(5), \mathrm{push}(7, 9):</tex>
[[Файл:стек.png|500px|nothumb|right|]]
{| border = 1; cellspacing = 0; class="wikitable"
|- align = "center"
!index
!1
!    2    
!    3    
!    4    
!    5    
!    6    
!    7    
!    8    
!    9    
|-align = "center"
!value
|<tex>null</tex>
|3
|5
|3
|6
|1
|<tex>null</tex>
|5
|9
|-align = "center"
!prev
|<tex>null</tex>
|1
|2
|1
|3
|5
|<tex>null</tex>
|2
|7
|}

В итоге мы имеем доступ ко всем версиям стека за <tex>O(1)</tex> времени и <tex>O(n)</tex> памяти.

== См. также==

* [[Стек]]
* [[Персистентный дек]]

== Источники информации ==

* [http://habrahabr.ru/blogs/algorithm/113585/ Habrahabr - Персистентный стек]

[[Категория:Дискретная математика и алгоритмы]]

[[Категория: Амортизационный анализ]]

АВЛ-дерево

2015-06-05T18:11:37Z

Паршуков Кирилл: /* Балансировка */

'''АВЛ-дерево''' (англ. ''AVL-Tree'') {{---}} сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором поддерживается следующее свойство: для каждой его вершины высота её двух поддеревьев различается не более чем на 1.

АВЛ-деревья названы по первым буквам фамилий их изобретателей, Г. М. Адельсона-Вельского и Е. М. Ландиса, которые впервые предложили использовать АВЛ-деревья в 1962 году.

== Высота дерева ==
{{Теорема
|statement=АВЛ-дерево с <tex>n</tex> ключами имеет высоту <tex>h = O(\log N)</tex>.
||proof=

Высоту поддерева с корнем <tex>x</tex> будем обозначать как <tex>h(x)</tex>, высоту поддерева <tex>T</tex> {{---}} как <tex>h(T)</tex>.

{{Лемма
|statement= Пусть <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>, тогда <tex>m_h = F_{h+2} - 1</tex>, где <tex>F_h - h</tex>-ое число Фибоначчи.
|proof=
Если <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>. Тогда, как легко видеть, <tex>m_{h+2} = m_{h+1} + m_h + 1</tex>. Равенство <tex>m_h = F_{h+2} - 1</tex> докажем по индукции.

База индукции <tex>m_1 = F_3 - 1</tex> {{---}} верно, <tex>m_1 = 1, F_3 = 2</tex>.

Допустим <tex>m_h = F_{h+2} - 1</tex> {{---}} верно.

Тогда <tex>m_{h+1} = m_h + m_{h-1} + 1 = F_{h+2} - 1 + F_{h+1} - 1 + 1 = F_{h+3} - 1</tex>.

Таким образом, равенство <tex>m_h = F_{h+2} - 1</tex> {{---}} доказано.
}}

<tex>F_h = \Omega(\varphi^h)</tex>, <tex>\varphi = \dfrac{ \sqrt{5}+1}{2}</tex>. То есть

<tex>n \geqslant \varphi^{h}</tex>

Логарифмируя по основанию <tex>\varphi</tex>, получаем

<tex>\log_{\varphi}n \geqslant h</tex>

Таким образом, получаем, что высота AVL-дерева из n вершин {{---}} <tex>O(\log{n})</tex>.
}}

== Балансировка ==
'''Балансировкой вершины''' называется операция, которая в случае разницы высот левого и правого поддеревьев <tex>|h(L) - h(R)| = 2</tex>, изменяет связи предок-потомок в поддереве данной вершины так, чтобы восстановилось свойство дерева <tex>|h(L) - h(R)| \leqslant 1</tex>, иначе ничего не меняет.
Для балансировки будем хранить для каждой вершины разницу между высотой её левого и правого поддерева <tex>diff[i] = h(L) - h(R)</tex>

Для балансировки вершины используются один из 4 типов вращений:

{| border="1" cellpadding="5" cellspacing="0"
!Тип вращения
!Иллюстрация
!Когда используется
!Расстановка балансов
|-
|'''Малое левое вращение'''
| [[Файл:avl_u1.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> и <tex>diff[b] = -1</tex>

или

<tex>diff[a] = -2</tex> и <tex>diff[b] = 0</tex>.
|

<tex>diff[a] = 0</tex> и <tex>diff[b] = 0</tex>

<tex>diff[a] = -1</tex> и <tex>diff[b] = 1</tex>
|-
|'''Большое левое вращение'''
| [[Файл:avl_u2.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> , <tex>diff[b] = 1</tex> и <tex>diff[c] = 1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = -1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = 0</tex>.
|

<tex>diff[a] = 0</tex>, <tex>diff[b] = -1</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 1</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 0</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>
|}
Малый левый поворот:
'''function''' rotateLeft(Node a):
Node b = a.right
a.right = b.left
b.left = a
корректировка высоты a
корректировка высоты b

Большой правый поворот пишется проще:
'''function''' bigRotateLeft(Node a):
rotateRight(a.right)
rotateLeft(a)

Малое правое и большое правое вращение определяются симметрично малому левому и большому левому вращению.
В каждом случае операция приводит к нужному результату, а полная высота уменьшается не более чем на <tex>1</tex> и не может увеличиться.

Все вращения, очевидно, требуют <tex>O(1)</tex> операций.

== Операции ==
=== Добавление вершины ===
Пусть нам надо добавить ключ <tex>t</tex>. Будем спускаться по дереву, как при поиске ключа <tex>t</tex>. Если мы стоим в вершине <tex>a</tex> и нам надо идти в поддерево, которого нет, то делаем ключ <tex>t</tex> листом, а вершину <tex>a</tex> его корнем. Дальше поднимаемся вверх по пути поиска и пересчитываем баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> увеличивается на единицу, если из правого, то уменьшается на единицу. Если пришли в вершину и её баланс стал равным нулю, то это значит высота поддерева не изменилась и подъём останавливается. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит высота поддерева изменилась и подъём продолжается. Если пришли в вершину и её баланс стал равным <tex>2</tex> или <tex>-2</tex>, то делаем одно из четырёх вращений и, если после вращения баланс стал равным нулю, то останавливаемся, иначе продолжаем подъём.

Так как в процессе добавления вершины мы рассматриваем не более, чем <tex> O(h) </tex> вершин дерева, и для каждой запускаем балансировку не более одного раза, то суммарное количество операций при включении новой вершины в дерево составляет <tex> O(\log{n}) </tex> операций.

=== Удаление вершины ===
Для простоты опишем рекурсивный алгоритм удаления.
Если вершина {{---}} лист, то [[Дерево поиска, наивная реализация#Удаление|удалим]] её, иначе найдём самую близкую по значению вершину <tex>a</tex>, переместим её на место удаляемой вершины и [[Дерево поиска, наивная реализация#Удаление|удалим]] вершину <tex>a</tex>. От удалённой вершины будем подниматься вверх к корню и пересчитывать баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> уменьшается на единицу, если из правого, то увеличивается на единицу. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит, что высота этого поддерева не изменилась и подъём можно остановить. Если баланс вершины стал равным нулю, то высота поддерева уменьшилась и подъём нужно продолжить. Если баланс стал равным <tex>2</tex> или <tex>-2</tex>, следует выполнить одно из четырёх вращений и, если после вращений баланс вершины стал равным нулю, то подъём продолжается, иначе останавливается.

В результате указанных действий на удаление вершины и балансировку суммарно тратится, как и ранее, <tex> O(h) </tex> операций. Таким образом, требуемое количество действий {{---}} <tex> O(\log{n}) </tex>.

=== Поиск вершины, минимум/максимум в дереве, etc. ===
Остальные операции не меняют структуры дерева, поэтому выполняются так же, как и в [[Дерево поиска, наивная реализация|наивной реализации]] дерева поиска.
===Слияние двух AVL-деревьев===

Дано два дерева <tex>T_1</tex> и <tex>T_2</tex>, все ключи в <tex>T_1</tex> меньше ключей в <tex>T_2</tex>, <tex>h(T_1) \leqslant h(T_2)</tex>.

В дереве <tex>T_1</tex> удаляем самую правую вершину, назовём её <tex>b</tex>. Высота дерева <tex>T_1</tex> может уменьшиться на единицу. В дереве <tex>T_2</tex> идём от корня всегда в левое поддерево и, когда высота этого поддерева <tex>P</tex> будет равна высоте дерева <tex>T_1</tex>, делаем новое дерево <tex>S</tex>, корнем <tex>S</tex> будет вершина <tex>b</tex>, левым поддеревом будет дерево <tex>T_1</tex>, а правым дерево <tex>P</tex>. Теперь в дереве <tex>T_2</tex> у вершины, в которой мы остановились при спуске, левым поддеревом делаем дерево <tex>S</tex> и запускаем балансировку. Таким образом, дерево <tex>T_2</tex> будет результатом слияния двух АВЛ-деревьев.

Дерево <tex>T_1</tex> и <tex>T_2</tex> до слияния

[[File:avl_u3.jpg|340px]]

Дерево <tex>T_2</tex> после слияния

[[File:avl_u4.jpg|300px]]

===Алгоритм разделения AVL-дерева на два===
====Алгоритм первый====
Пусть у нас есть дерево <tex>T</tex>. Мы должны разбить его на два дерева <tex>T_{1}</tex> и <tex>T_{2}</tex> такие, что <tex>T_{1} \leqslant x</tex> и <tex>x < T_{2}</tex>.

Предположим, что корень нашего дерева <tex>\leqslant x</tex>, в таком случае все левое поддерево вместе с корнем после разделения отойдет в дерево <tex>T_{1}</tex>. Тогда рекурсивно спускаемся в правое поддерево и там проверяем это условие (так как часть правого поддерева тоже может содержать ключи <tex>\leqslant x</tex>). Если же корень оказался <tex>> x</tex>, то мы спускаемся той же рекурсией, но только в левое поддерево и ищем там.

Пусть мы пришли в поддерево <tex>S</tex>, корень которого <tex>\leqslant x</tex>. В таком случае этот корень со своим левым поддеревом должен отойти в дерево <tex>T_{1}</tex>. Поэтому мы делаем следующее: запоминаем ссылку на правое поддерево <tex>S</tex>, удаляем корень, запоминая его значение (не меняя конфигурацию дерева, то есть просто делаем ссылки на него NULL'ами). Таким образом, мы отделяем сбалансированное АВЛ-дерево (бывшее левое поддерево <tex>S</tex>). Делаем новую вершину со значением бывшего корня правым листом самой правой вершины <tex>S</tex> и запускаем балансировку. Обозначим полученное дерево за <tex>T'</tex>. Теперь нам нужно объединить его с уже построенным ранее <tex>T_{1}</tex> (оно может быть пустым, если мы первый раз нашли такое дерево <tex>S</tex>). Для этого мы ищем в дереве <tex>T_{1}</tex> самое правое поддерево <tex>P</tex> высоты, равной высоте <tex>T'</tex> (спускаясь от корня всегда в правые поддеревья). Делаем новое дерево <tex>K</tex>, сливая <tex>P</tex> и <tex>T'</tex> (очевидно, все ключи в <tex>T_{1}</tex> меньше ключей в <tex>T'</tex>, поэтому мы можем это сделать). Теперь в дереве <tex>T_{1}</tex> у отца вершины, в которой мы остановились при поиске дерева <tex>P</tex>, правым поддеревом делаем дерево <tex>K</tex> и запускаем балансировку. После нужно спуститься в правое поддерево бывшего дерева <tex>S</tex> (по ссылке, которую мы ранее запомнили) и обработать его.

Если мы пришли в поддерево <tex>Q</tex>, корень которого <tex>> x</tex>, совершаем аналогичные действия: делаем NULL'ами ссылки на корень <tex>Q</tex>, запоминая ссылку на его левое поддерево. Делаем новую вершину со значением бывшего корня левым листом самой левой вершины <tex>Q</tex> и запускаем балансировку. Объединяем полученное АВЛ-дерево с уже построенным ранее <tex>T_{2}</tex> аналогичным первому случаю способом, только теперь мы ищем самое левое поддерево <tex>T_{2}</tex>.

Рассмотри пример (рис. 1). Цветом выделены поддеревья, которые после разделения должны отойти в дерево <tex>T_{1}</tex>. <tex>x = 76</tex>.

{| cellpadding="2"
| || [[Файл:AVL.jpg|thumb|left|525px|Рис. 1. Разделение АВЛ-дерева на два.]]
|}

Корень дерева <tex>\leqslant x</tex>, поэтому он со всем выделенным поддеревом должен отойти в дерево <tex>T_{1}</tex>. По описанному выше алгоритму отделяем это поддерево с корнем и делаем из них сбалансированное АВЛ-дерево <tex>T'</tex> (рис. 2). Так как это первая ситуация, в которой корень рассматриваемого поддерева был <tex>\leqslant x</tex>, <tex>T'</tex> становится <tex>T_{1}</tex>. Далее по сохраненной ссылке спускаемся в правое поддерево. Его корень <tex>> x</tex>. Следовательно, строим из него и его правого поддерева <tex>T_{2}</tex> и спускаемся в левое поддерево. Снова корень <tex>\leqslant x</tex>. Строим новое <tex>T'</tex> и объединяем его с уже существующим <tex>T_{1}</tex> (рис. 3).

{| cellpadding="2"
| || [[Файл:АВВЛ2.jpg|thumb|left|525px|Рис. 2. Создание T'.]]
|}
{| cellpadding="2"
| || [[Файл:AVL3.jpg|thumb|left|1050px|Рис. 3. Объединение T' и T1.]]
|}

Далее действуем по алгоритму и в итоге получаем (рис. 4):

{| cellpadding="2"
| || [[Файл:End.jpg|thumb|left|525px|Рис. 4. АВЛ-деревья после разделения.]]
|}

Данный алгоритм имеет сложность <tex>O(\log^{2} n)</tex>.

====Алгоритм второй====
Рассмотрим решение, которое имеет сложность <tex>O(\log{n})</tex>.

Вернемся к примеру (рис. 1). Теперь рекурсивно спустимся вниз и оттуда будем строить деревья <tex>T_{1}</tex> и <tex>T_{2}</tex>, передавая наверх корректные АВЛ-деревья. То есть для рис. 1 первым в дерево <tex>T_{1}</tex> придет вершина <tex>75</tex> с левым поддеревом (выделено светло-зеленым цветом), так как это корректное АВЛ-дерево, оно же и вернется из рекурсии. Далее мы попадем в вершину со значением <tex>70</tex> и должны слить ее и ее левое поддерево (выделено светло-синим) с тем, что нам пришло. И сделать это нужно так, чтобы передать наверх корректное АВЛ-дерево. Будем действовать по такому алгоритму, пока не дойдем до вершины.

Пусть мы пришли в поддерево <tex>S</tex> с корнем <tex>\leqslant x</tex>. Тогда сольем его с уже построенным на тот момент <tex>T_{1}</tex> (<tex>T_{1}</tex> пришло снизу, а значит по условию рекурсии это корректное АВЛ-дерево, <tex>S \leqslant T_{1}</tex> и <tex>h(T_{1}) \leqslant h(S)</tex>). Но так как обычная процедура слияния сливает два АВЛ-дерева, а <tex>S</tex> не является корректным АВЛ-деревом, мы немного ее изменим. Пусть мы в дереве <tex>S</tex> нашли самое правое поддерево <tex>K</tex>, высота которого равна высоте <tex>T_{1}</tex>. Тогда сделаем новое дерево <tex>T'</tex>, корнем которого будет вершина <tex>S</tex> (без нее это дерево является сбалансированным), правым поддеревом {{---}} <tex>T_{1}</tex>, левым {{---}} <tex>K</tex>. И подвесим <tex>T'</tex> на то место, где мы остановились при поиске <tex>K</tex>. Запустим балансировку. В случае, когда корень поддерева, в которое мы пришли, <tex>> x</tex>, все аналогично.

Разберем пример на рис. 1. Пусть мы рекурсивно спустились до узла <tex>77</tex>. Ключ больше <tex>x</tex>, поэтому эта вершина станет деревом <tex>T_{2}</tex> и передастся наверх. Теперь мы поднялись в узел <tex>75</tex>. Он со своим левым поддеревом станет деревом <tex>T_{1}</tex> и мы снова поднимемся наверх в узел <tex>70</tex>. Он со своим левым поддеревом снова должен отойти в дерево <tex>T_{1}</tex>, и так как теперь дерево <tex>T_{1}</tex> уже не пустое, то их надо слить. После слияния по описанному выше алгоритму получим (рис. 5)

{| cellpadding="2"
| || [[Файл:Ex.jpg|thumb|left|525px|Рис. 5.]]
|}

После мы поднимемся в вершину с ключом <tex>80</tex>. Она с правым поддеревом отойдет в дерево <tex>T_{2}</tex> (рис. 6).

{| cellpadding="2"
| || [[Файл:Ex2am.jpg|thumb|left|525px|Рис. 6.]]
|}

И на последней итерации мы поднимемся в корень дерева с ключом <tex>50</tex>, он с левым поддеревом отойдет в дерево <tex>T_{1}</tex>, после чего алгоритм завершится.

Пусть поддеревьев с ключами <tex>\leqslant x</tex> оказалось больше, чем поддеревьев с ключами <tex>> x</tex>. Докажем для них логарифмическую асимптотику. Дерево на последнем уровне имеет высоту <tex>H_{k}</tex> (она может быть не равна <tex>1</tex>, если мы придём в <tex>x</tex>). Его мы передаем наверх и вставляем в поддерево высотой <tex>H_{k-1}</tex>. <tex>H_{k} \leqslant H_{k-1}</tex>, так как разница высот поддеревьев у любой вершины не больше <tex>1</tex>, и мы при переходе от <tex>H_{k}</tex> к <tex>H_{k-1}</tex> поднимаемся как минимум на одну вершину вверх. Слияние этих поддеревьев мы выполним за <tex>H_{k-1} - H_{k}</tex>, получим в итоге дерево высоты не большей, чем <tex>H_{k-1}</tex>. Его мы передадим наверх, поэтому в следующий раз слияние будет выполнено за <tex>H_{k-2} - H_{k - 1}</tex> и так далее. Таким образом мы получим <tex>(H - H_{1}) + (H_{1} - H_{2}) + (H_{2} - H_{3}) + \cdots + (H_{k - 1} - H_{k}) = H - H_{k} = O(\log{n})</tex>.

Итоговая асимптотика алгоритма {{---}} <tex>O(\log{n})</tex>.

== См. также ==
* [[Splay-дерево]]
* [[Красно-черное дерево]]
* [[2-3 дерево]]

== Источники информации ==
* [http://habrahabr.ru/post/150732/ Habrahabr {{---}} АВЛ-деревья]
* [http://ru.wikipedia.org/wiki/АВЛ-дерево Википедия {{---}} АВЛ-дерево]

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Деревья поиска]]
[[Категория:Структуры данных]]

АВЛ-дерево

2015-06-05T18:09:57Z

Паршуков Кирилл: /* Балансировка */

'''АВЛ-дерево''' (англ. ''AVL-Tree'') {{---}} сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором поддерживается следующее свойство: для каждой его вершины высота её двух поддеревьев различается не более чем на 1.

АВЛ-деревья названы по первым буквам фамилий их изобретателей, Г. М. Адельсона-Вельского и Е. М. Ландиса, которые впервые предложили использовать АВЛ-деревья в 1962 году.

== Высота дерева ==
{{Теорема
|statement=АВЛ-дерево с <tex>n</tex> ключами имеет высоту <tex>h = O(\log N)</tex>.
||proof=

Высоту поддерева с корнем <tex>x</tex> будем обозначать как <tex>h(x)</tex>, высоту поддерева <tex>T</tex> {{---}} как <tex>h(T)</tex>.

{{Лемма
|statement= Пусть <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>, тогда <tex>m_h = F_{h+2} - 1</tex>, где <tex>F_h - h</tex>-ое число Фибоначчи.
|proof=
Если <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>. Тогда, как легко видеть, <tex>m_{h+2} = m_{h+1} + m_h + 1</tex>. Равенство <tex>m_h = F_{h+2} - 1</tex> докажем по индукции.

База индукции <tex>m_1 = F_3 - 1</tex> {{---}} верно, <tex>m_1 = 1, F_3 = 2</tex>.

Допустим <tex>m_h = F_{h+2} - 1</tex> {{---}} верно.

Тогда <tex>m_{h+1} = m_h + m_{h-1} + 1 = F_{h+2} - 1 + F_{h+1} - 1 + 1 = F_{h+3} - 1</tex>.

Таким образом, равенство <tex>m_h = F_{h+2} - 1</tex> {{---}} доказано.
}}

<tex>F_h = \Omega(\varphi^h)</tex>, <tex>\varphi = \dfrac{ \sqrt{5}+1}{2}</tex>. То есть

<tex>n \geqslant \varphi^{h}</tex>

Логарифмируя по основанию <tex>\varphi</tex>, получаем

<tex>\log_{\varphi}n \geqslant h</tex>

Таким образом, получаем, что высота AVL-дерева из n вершин {{---}} <tex>O(\log{n})</tex>.
}}

== Балансировка ==
'''Балансировкой вершины''' называется операция, которая в случае разницы высот левого и правого поддеревьев <tex>|h(L) - h(R)| = 2</tex>, изменяет связи предок-потомок в поддереве данной вершины так, чтобы восстановилось свойство дерева <tex>|h(L) - h(R)| \leqslant 1</tex>, иначе ничего не меняет.
Для балансировки будем хранить для каждой вершины разницу между высотой её левого и правого поддерева <tex>diff[i] = h(L) - h(R)</tex>

Для балансировки вершины используются один из 4 типов вращений:

{| border="1" cellpadding="5" cellspacing="0"
!Тип вращения
!Иллюстрация
!Когда используется
!Расстановка балансов
|-
|'''Малое левое вращение'''
| [[Файл:avl_u1.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> и <tex>diff[b] = -1</tex>

или

<tex>diff[a] = -2</tex> и <tex>diff[b] = 0</tex>.
|

<tex>diff[a] = 0</tex> и <tex>diff[b] = 0</tex>

<tex>diff[a] = -1</tex> и <tex>diff[b] = 1</tex>
|-
|'''Большое левое вращение'''
| [[Файл:avl_u2.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> , <tex>diff[b] = 1</tex> и <tex>diff[c] = 1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = -1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = 0</tex>.
|

<tex>diff[a] = 0</tex>, <tex>diff[b] = -1</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 1</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 0</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>
|}
Малый левый поворот:
'''function''' rotateLeft(Node a):
Node b = a.right
a.right = b.left
b.left = a
корректировка высоты a
корректировка высоты b

Большой правый поворот пишется проще:
'''function''' bigRotateLeft(Node a):
rotateRight(a.right)
rotateLeft(a)

Малое правое и большое правое вращение определяются симметрично малому левому и большому левому вращению.
В каждом случае операция приводит к нужному результату, а полная высота уменьшается не более чем на <tex>1</tex> и не может увеличиться.

Все операции вращения, очевидно, требуют <tex>O(1)</tex> операций.

== Операции ==
=== Добавление вершины ===
Пусть нам надо добавить ключ <tex>t</tex>. Будем спускаться по дереву, как при поиске ключа <tex>t</tex>. Если мы стоим в вершине <tex>a</tex> и нам надо идти в поддерево, которого нет, то делаем ключ <tex>t</tex> листом, а вершину <tex>a</tex> его корнем. Дальше поднимаемся вверх по пути поиска и пересчитываем баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> увеличивается на единицу, если из правого, то уменьшается на единицу. Если пришли в вершину и её баланс стал равным нулю, то это значит высота поддерева не изменилась и подъём останавливается. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит высота поддерева изменилась и подъём продолжается. Если пришли в вершину и её баланс стал равным <tex>2</tex> или <tex>-2</tex>, то делаем одно из четырёх вращений и, если после вращения баланс стал равным нулю, то останавливаемся, иначе продолжаем подъём.

Так как в процессе добавления вершины мы рассматриваем не более, чем <tex> O(h) </tex> вершин дерева, и для каждой запускаем балансировку не более одного раза, то суммарное количество операций при включении новой вершины в дерево составляет <tex> O(\log{n}) </tex> операций.

=== Удаление вершины ===
Для простоты опишем рекурсивный алгоритм удаления.
Если вершина {{---}} лист, то [[Дерево поиска, наивная реализация#Удаление|удалим]] её, иначе найдём самую близкую по значению вершину <tex>a</tex>, переместим её на место удаляемой вершины и [[Дерево поиска, наивная реализация#Удаление|удалим]] вершину <tex>a</tex>. От удалённой вершины будем подниматься вверх к корню и пересчитывать баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> уменьшается на единицу, если из правого, то увеличивается на единицу. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит, что высота этого поддерева не изменилась и подъём можно остановить. Если баланс вершины стал равным нулю, то высота поддерева уменьшилась и подъём нужно продолжить. Если баланс стал равным <tex>2</tex> или <tex>-2</tex>, следует выполнить одно из четырёх вращений и, если после вращений баланс вершины стал равным нулю, то подъём продолжается, иначе останавливается.

В результате указанных действий на удаление вершины и балансировку суммарно тратится, как и ранее, <tex> O(h) </tex> операций. Таким образом, требуемое количество действий {{---}} <tex> O(\log{n}) </tex>.

=== Поиск вершины, минимум/максимум в дереве, etc. ===
Остальные операции не меняют структуры дерева, поэтому выполняются так же, как и в [[Дерево поиска, наивная реализация|наивной реализации]] дерева поиска.
===Слияние двух AVL-деревьев===

Дано два дерева <tex>T_1</tex> и <tex>T_2</tex>, все ключи в <tex>T_1</tex> меньше ключей в <tex>T_2</tex>, <tex>h(T_1) \leqslant h(T_2)</tex>.

В дереве <tex>T_1</tex> удаляем самую правую вершину, назовём её <tex>b</tex>. Высота дерева <tex>T_1</tex> может уменьшиться на единицу. В дереве <tex>T_2</tex> идём от корня всегда в левое поддерево и, когда высота этого поддерева <tex>P</tex> будет равна высоте дерева <tex>T_1</tex>, делаем новое дерево <tex>S</tex>, корнем <tex>S</tex> будет вершина <tex>b</tex>, левым поддеревом будет дерево <tex>T_1</tex>, а правым дерево <tex>P</tex>. Теперь в дереве <tex>T_2</tex> у вершины, в которой мы остановились при спуске, левым поддеревом делаем дерево <tex>S</tex> и запускаем балансировку. Таким образом, дерево <tex>T_2</tex> будет результатом слияния двух АВЛ-деревьев.

Дерево <tex>T_1</tex> и <tex>T_2</tex> до слияния

[[File:avl_u3.jpg|340px]]

Дерево <tex>T_2</tex> после слияния

[[File:avl_u4.jpg|300px]]

===Алгоритм разделения AVL-дерева на два===
====Алгоритм первый====
Пусть у нас есть дерево <tex>T</tex>. Мы должны разбить его на два дерева <tex>T_{1}</tex> и <tex>T_{2}</tex> такие, что <tex>T_{1} \leqslant x</tex> и <tex>x < T_{2}</tex>.

Предположим, что корень нашего дерева <tex>\leqslant x</tex>, в таком случае все левое поддерево вместе с корнем после разделения отойдет в дерево <tex>T_{1}</tex>. Тогда рекурсивно спускаемся в правое поддерево и там проверяем это условие (так как часть правого поддерева тоже может содержать ключи <tex>\leqslant x</tex>). Если же корень оказался <tex>> x</tex>, то мы спускаемся той же рекурсией, но только в левое поддерево и ищем там.

Пусть мы пришли в поддерево <tex>S</tex>, корень которого <tex>\leqslant x</tex>. В таком случае этот корень со своим левым поддеревом должен отойти в дерево <tex>T_{1}</tex>. Поэтому мы делаем следующее: запоминаем ссылку на правое поддерево <tex>S</tex>, удаляем корень, запоминая его значение (не меняя конфигурацию дерева, то есть просто делаем ссылки на него NULL'ами). Таким образом, мы отделяем сбалансированное АВЛ-дерево (бывшее левое поддерево <tex>S</tex>). Делаем новую вершину со значением бывшего корня правым листом самой правой вершины <tex>S</tex> и запускаем балансировку. Обозначим полученное дерево за <tex>T'</tex>. Теперь нам нужно объединить его с уже построенным ранее <tex>T_{1}</tex> (оно может быть пустым, если мы первый раз нашли такое дерево <tex>S</tex>). Для этого мы ищем в дереве <tex>T_{1}</tex> самое правое поддерево <tex>P</tex> высоты, равной высоте <tex>T'</tex> (спускаясь от корня всегда в правые поддеревья). Делаем новое дерево <tex>K</tex>, сливая <tex>P</tex> и <tex>T'</tex> (очевидно, все ключи в <tex>T_{1}</tex> меньше ключей в <tex>T'</tex>, поэтому мы можем это сделать). Теперь в дереве <tex>T_{1}</tex> у отца вершины, в которой мы остановились при поиске дерева <tex>P</tex>, правым поддеревом делаем дерево <tex>K</tex> и запускаем балансировку. После нужно спуститься в правое поддерево бывшего дерева <tex>S</tex> (по ссылке, которую мы ранее запомнили) и обработать его.

Если мы пришли в поддерево <tex>Q</tex>, корень которого <tex>> x</tex>, совершаем аналогичные действия: делаем NULL'ами ссылки на корень <tex>Q</tex>, запоминая ссылку на его левое поддерево. Делаем новую вершину со значением бывшего корня левым листом самой левой вершины <tex>Q</tex> и запускаем балансировку. Объединяем полученное АВЛ-дерево с уже построенным ранее <tex>T_{2}</tex> аналогичным первому случаю способом, только теперь мы ищем самое левое поддерево <tex>T_{2}</tex>.

Рассмотри пример (рис. 1). Цветом выделены поддеревья, которые после разделения должны отойти в дерево <tex>T_{1}</tex>. <tex>x = 76</tex>.

{| cellpadding="2"
| || [[Файл:AVL.jpg|thumb|left|525px|Рис. 1. Разделение АВЛ-дерева на два.]]
|}

Корень дерева <tex>\leqslant x</tex>, поэтому он со всем выделенным поддеревом должен отойти в дерево <tex>T_{1}</tex>. По описанному выше алгоритму отделяем это поддерево с корнем и делаем из них сбалансированное АВЛ-дерево <tex>T'</tex> (рис. 2). Так как это первая ситуация, в которой корень рассматриваемого поддерева был <tex>\leqslant x</tex>, <tex>T'</tex> становится <tex>T_{1}</tex>. Далее по сохраненной ссылке спускаемся в правое поддерево. Его корень <tex>> x</tex>. Следовательно, строим из него и его правого поддерева <tex>T_{2}</tex> и спускаемся в левое поддерево. Снова корень <tex>\leqslant x</tex>. Строим новое <tex>T'</tex> и объединяем его с уже существующим <tex>T_{1}</tex> (рис. 3).

{| cellpadding="2"
| || [[Файл:АВВЛ2.jpg|thumb|left|525px|Рис. 2. Создание T'.]]
|}
{| cellpadding="2"
| || [[Файл:AVL3.jpg|thumb|left|1050px|Рис. 3. Объединение T' и T1.]]
|}

Далее действуем по алгоритму и в итоге получаем (рис. 4):

{| cellpadding="2"
| || [[Файл:End.jpg|thumb|left|525px|Рис. 4. АВЛ-деревья после разделения.]]
|}

Данный алгоритм имеет сложность <tex>O(\log^{2} n)</tex>.

====Алгоритм второй====
Рассмотрим решение, которое имеет сложность <tex>O(\log{n})</tex>.

Вернемся к примеру (рис. 1). Теперь рекурсивно спустимся вниз и оттуда будем строить деревья <tex>T_{1}</tex> и <tex>T_{2}</tex>, передавая наверх корректные АВЛ-деревья. То есть для рис. 1 первым в дерево <tex>T_{1}</tex> придет вершина <tex>75</tex> с левым поддеревом (выделено светло-зеленым цветом), так как это корректное АВЛ-дерево, оно же и вернется из рекурсии. Далее мы попадем в вершину со значением <tex>70</tex> и должны слить ее и ее левое поддерево (выделено светло-синим) с тем, что нам пришло. И сделать это нужно так, чтобы передать наверх корректное АВЛ-дерево. Будем действовать по такому алгоритму, пока не дойдем до вершины.

Пусть мы пришли в поддерево <tex>S</tex> с корнем <tex>\leqslant x</tex>. Тогда сольем его с уже построенным на тот момент <tex>T_{1}</tex> (<tex>T_{1}</tex> пришло снизу, а значит по условию рекурсии это корректное АВЛ-дерево, <tex>S \leqslant T_{1}</tex> и <tex>h(T_{1}) \leqslant h(S)</tex>). Но так как обычная процедура слияния сливает два АВЛ-дерева, а <tex>S</tex> не является корректным АВЛ-деревом, мы немного ее изменим. Пусть мы в дереве <tex>S</tex> нашли самое правое поддерево <tex>K</tex>, высота которого равна высоте <tex>T_{1}</tex>. Тогда сделаем новое дерево <tex>T'</tex>, корнем которого будет вершина <tex>S</tex> (без нее это дерево является сбалансированным), правым поддеревом {{---}} <tex>T_{1}</tex>, левым {{---}} <tex>K</tex>. И подвесим <tex>T'</tex> на то место, где мы остановились при поиске <tex>K</tex>. Запустим балансировку. В случае, когда корень поддерева, в которое мы пришли, <tex>> x</tex>, все аналогично.

Разберем пример на рис. 1. Пусть мы рекурсивно спустились до узла <tex>77</tex>. Ключ больше <tex>x</tex>, поэтому эта вершина станет деревом <tex>T_{2}</tex> и передастся наверх. Теперь мы поднялись в узел <tex>75</tex>. Он со своим левым поддеревом станет деревом <tex>T_{1}</tex> и мы снова поднимемся наверх в узел <tex>70</tex>. Он со своим левым поддеревом снова должен отойти в дерево <tex>T_{1}</tex>, и так как теперь дерево <tex>T_{1}</tex> уже не пустое, то их надо слить. После слияния по описанному выше алгоритму получим (рис. 5)

{| cellpadding="2"
| || [[Файл:Ex.jpg|thumb|left|525px|Рис. 5.]]
|}

После мы поднимемся в вершину с ключом <tex>80</tex>. Она с правым поддеревом отойдет в дерево <tex>T_{2}</tex> (рис. 6).

{| cellpadding="2"
| || [[Файл:Ex2am.jpg|thumb|left|525px|Рис. 6.]]
|}

И на последней итерации мы поднимемся в корень дерева с ключом <tex>50</tex>, он с левым поддеревом отойдет в дерево <tex>T_{1}</tex>, после чего алгоритм завершится.

Пусть поддеревьев с ключами <tex>\leqslant x</tex> оказалось больше, чем поддеревьев с ключами <tex>> x</tex>. Докажем для них логарифмическую асимптотику. Дерево на последнем уровне имеет высоту <tex>H_{k}</tex> (она может быть не равна <tex>1</tex>, если мы придём в <tex>x</tex>). Его мы передаем наверх и вставляем в поддерево высотой <tex>H_{k-1}</tex>. <tex>H_{k} \leqslant H_{k-1}</tex>, так как разница высот поддеревьев у любой вершины не больше <tex>1</tex>, и мы при переходе от <tex>H_{k}</tex> к <tex>H_{k-1}</tex> поднимаемся как минимум на одну вершину вверх. Слияние этих поддеревьев мы выполним за <tex>H_{k-1} - H_{k}</tex>, получим в итоге дерево высоты не большей, чем <tex>H_{k-1}</tex>. Его мы передадим наверх, поэтому в следующий раз слияние будет выполнено за <tex>H_{k-2} - H_{k - 1}</tex> и так далее. Таким образом мы получим <tex>(H - H_{1}) + (H_{1} - H_{2}) + (H_{2} - H_{3}) + \cdots + (H_{k - 1} - H_{k}) = H - H_{k} = O(\log{n})</tex>.

Итоговая асимптотика алгоритма {{---}} <tex>O(\log{n})</tex>.

== См. также ==
* [[Splay-дерево]]
* [[Красно-черное дерево]]
* [[2-3 дерево]]

== Источники информации ==
* [http://habrahabr.ru/post/150732/ Habrahabr {{---}} АВЛ-деревья]
* [http://ru.wikipedia.org/wiki/АВЛ-дерево Википедия {{---}} АВЛ-дерево]

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Деревья поиска]]
[[Категория:Структуры данных]]

АВЛ-дерево

2015-06-05T18:07:34Z

Паршуков Кирилл: /* Балансировка */

'''АВЛ-дерево''' (англ. ''AVL-Tree'') {{---}} сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором поддерживается следующее свойство: для каждой его вершины высота её двух поддеревьев различается не более чем на 1.

АВЛ-деревья названы по первым буквам фамилий их изобретателей, Г. М. Адельсона-Вельского и Е. М. Ландиса, которые впервые предложили использовать АВЛ-деревья в 1962 году.

== Высота дерева ==
{{Теорема
|statement=АВЛ-дерево с <tex>n</tex> ключами имеет высоту <tex>h = O(\log N)</tex>.
||proof=

Высоту поддерева с корнем <tex>x</tex> будем обозначать как <tex>h(x)</tex>, высоту поддерева <tex>T</tex> {{---}} как <tex>h(T)</tex>.

{{Лемма
|statement= Пусть <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>, тогда <tex>m_h = F_{h+2} - 1</tex>, где <tex>F_h - h</tex>-ое число Фибоначчи.
|proof=
Если <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>. Тогда, как легко видеть, <tex>m_{h+2} = m_{h+1} + m_h + 1</tex>. Равенство <tex>m_h = F_{h+2} - 1</tex> докажем по индукции.

База индукции <tex>m_1 = F_3 - 1</tex> {{---}} верно, <tex>m_1 = 1, F_3 = 2</tex>.

Допустим <tex>m_h = F_{h+2} - 1</tex> {{---}} верно.

Тогда <tex>m_{h+1} = m_h + m_{h-1} + 1 = F_{h+2} - 1 + F_{h+1} - 1 + 1 = F_{h+3} - 1</tex>.

Таким образом, равенство <tex>m_h = F_{h+2} - 1</tex> {{---}} доказано.
}}

<tex>F_h = \Omega(\varphi^h)</tex>, <tex>\varphi = \dfrac{ \sqrt{5}+1}{2}</tex>. То есть

<tex>n \geqslant \varphi^{h}</tex>

Логарифмируя по основанию <tex>\varphi</tex>, получаем

<tex>\log_{\varphi}n \geqslant h</tex>

Таким образом, получаем, что высота AVL-дерева из n вершин {{---}} <tex>O(\log{n})</tex>.
}}

== Балансировка ==
'''Балансировкой вершины''' называется операция, которая в случае разницы высот левого и правого поддеревьев <tex>|h(L) - h(R)| = 2</tex>, изменяет связи предок-потомок в поддереве данной вершины так, чтобы восстановилось свойство дерева <tex>|h(L) - h(R)| \leqslant 1</tex>, иначе ничего не меняет.
Для балансировки будем хранить для каждой вершины разницу между высотой её левого и правого поддерева <tex>diff[i] = h(L) - h(R)</tex>

Для балансировки вершины используются один из 4 типов вращений:

{| border="1" cellpadding="5" cellspacing="0"
!Тип вращения
!Иллюстрация
!Когда используется
!Расстановка балансов
|-
|'''Малое левое вращение'''
| [[Файл:avl_u1.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> и <tex>diff[b] = -1</tex>

или

<tex>diff[a] = -2</tex> и <tex>diff[b] = 0</tex>.
|

<tex>diff[a] = 0</tex> и <tex>diff[b] = 0</tex>

<tex>diff[a] = -1</tex> и <tex>diff[b] = 1</tex>
|-
|'''Большое левое вращение'''
| [[Файл:avl_u2.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> , <tex>diff[b] = 1</tex> и <tex>diff[c] = 1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = -1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = 0</tex>.
|

<tex>diff[a] = 0</tex>, <tex>diff[b] = -1</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 1</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 0</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>
|}
Малый левый поворот:
'''function''' rotateleft(Node a):
Node b = a.right
a.right = b.left
b.left = a
fixheight(a)
fixheight(b)

Большой правый поворот пишется проще:
'''function''' bigrotateleft(Node a):
rotateright(a.right)
rotateleft(a)

Малое правое и большое правое вращение определяются симметрично малому левому и большому левому вращению.
В каждом случае операция приводит к нужному результату, а полная высота уменьшается не более чем на <tex>1</tex> и не может увеличиться.

Все операции вращения, очевидно, требуют <tex>O(1)</tex> операций.

== Операции ==
=== Добавление вершины ===
Пусть нам надо добавить ключ <tex>t</tex>. Будем спускаться по дереву, как при поиске ключа <tex>t</tex>. Если мы стоим в вершине <tex>a</tex> и нам надо идти в поддерево, которого нет, то делаем ключ <tex>t</tex> листом, а вершину <tex>a</tex> его корнем. Дальше поднимаемся вверх по пути поиска и пересчитываем баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> увеличивается на единицу, если из правого, то уменьшается на единицу. Если пришли в вершину и её баланс стал равным нулю, то это значит высота поддерева не изменилась и подъём останавливается. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит высота поддерева изменилась и подъём продолжается. Если пришли в вершину и её баланс стал равным <tex>2</tex> или <tex>-2</tex>, то делаем одно из четырёх вращений и, если после вращения баланс стал равным нулю, то останавливаемся, иначе продолжаем подъём.

Так как в процессе добавления вершины мы рассматриваем не более, чем <tex> O(h) </tex> вершин дерева, и для каждой запускаем балансировку не более одного раза, то суммарное количество операций при включении новой вершины в дерево составляет <tex> O(\log{n}) </tex> операций.

=== Удаление вершины ===
Для простоты опишем рекурсивный алгоритм удаления.
Если вершина {{---}} лист, то [[Дерево поиска, наивная реализация#Удаление|удалим]] её, иначе найдём самую близкую по значению вершину <tex>a</tex>, переместим её на место удаляемой вершины и [[Дерево поиска, наивная реализация#Удаление|удалим]] вершину <tex>a</tex>. От удалённой вершины будем подниматься вверх к корню и пересчитывать баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> уменьшается на единицу, если из правого, то увеличивается на единицу. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит, что высота этого поддерева не изменилась и подъём можно остановить. Если баланс вершины стал равным нулю, то высота поддерева уменьшилась и подъём нужно продолжить. Если баланс стал равным <tex>2</tex> или <tex>-2</tex>, следует выполнить одно из четырёх вращений и, если после вращений баланс вершины стал равным нулю, то подъём продолжается, иначе останавливается.

В результате указанных действий на удаление вершины и балансировку суммарно тратится, как и ранее, <tex> O(h) </tex> операций. Таким образом, требуемое количество действий {{---}} <tex> O(\log{n}) </tex>.

=== Поиск вершины, минимум/максимум в дереве, etc. ===
Остальные операции не меняют структуры дерева, поэтому выполняются так же, как и в [[Дерево поиска, наивная реализация|наивной реализации]] дерева поиска.
===Слияние двух AVL-деревьев===

Дано два дерева <tex>T_1</tex> и <tex>T_2</tex>, все ключи в <tex>T_1</tex> меньше ключей в <tex>T_2</tex>, <tex>h(T_1) \leqslant h(T_2)</tex>.

В дереве <tex>T_1</tex> удаляем самую правую вершину, назовём её <tex>b</tex>. Высота дерева <tex>T_1</tex> может уменьшиться на единицу. В дереве <tex>T_2</tex> идём от корня всегда в левое поддерево и, когда высота этого поддерева <tex>P</tex> будет равна высоте дерева <tex>T_1</tex>, делаем новое дерево <tex>S</tex>, корнем <tex>S</tex> будет вершина <tex>b</tex>, левым поддеревом будет дерево <tex>T_1</tex>, а правым дерево <tex>P</tex>. Теперь в дереве <tex>T_2</tex> у вершины, в которой мы остановились при спуске, левым поддеревом делаем дерево <tex>S</tex> и запускаем балансировку. Таким образом, дерево <tex>T_2</tex> будет результатом слияния двух АВЛ-деревьев.

Дерево <tex>T_1</tex> и <tex>T_2</tex> до слияния

[[File:avl_u3.jpg|340px]]

Дерево <tex>T_2</tex> после слияния

[[File:avl_u4.jpg|300px]]

===Алгоритм разделения AVL-дерева на два===
====Алгоритм первый====
Пусть у нас есть дерево <tex>T</tex>. Мы должны разбить его на два дерева <tex>T_{1}</tex> и <tex>T_{2}</tex> такие, что <tex>T_{1} \leqslant x</tex> и <tex>x < T_{2}</tex>.

Предположим, что корень нашего дерева <tex>\leqslant x</tex>, в таком случае все левое поддерево вместе с корнем после разделения отойдет в дерево <tex>T_{1}</tex>. Тогда рекурсивно спускаемся в правое поддерево и там проверяем это условие (так как часть правого поддерева тоже может содержать ключи <tex>\leqslant x</tex>). Если же корень оказался <tex>> x</tex>, то мы спускаемся той же рекурсией, но только в левое поддерево и ищем там.

Пусть мы пришли в поддерево <tex>S</tex>, корень которого <tex>\leqslant x</tex>. В таком случае этот корень со своим левым поддеревом должен отойти в дерево <tex>T_{1}</tex>. Поэтому мы делаем следующее: запоминаем ссылку на правое поддерево <tex>S</tex>, удаляем корень, запоминая его значение (не меняя конфигурацию дерева, то есть просто делаем ссылки на него NULL'ами). Таким образом, мы отделяем сбалансированное АВЛ-дерево (бывшее левое поддерево <tex>S</tex>). Делаем новую вершину со значением бывшего корня правым листом самой правой вершины <tex>S</tex> и запускаем балансировку. Обозначим полученное дерево за <tex>T'</tex>. Теперь нам нужно объединить его с уже построенным ранее <tex>T_{1}</tex> (оно может быть пустым, если мы первый раз нашли такое дерево <tex>S</tex>). Для этого мы ищем в дереве <tex>T_{1}</tex> самое правое поддерево <tex>P</tex> высоты, равной высоте <tex>T'</tex> (спускаясь от корня всегда в правые поддеревья). Делаем новое дерево <tex>K</tex>, сливая <tex>P</tex> и <tex>T'</tex> (очевидно, все ключи в <tex>T_{1}</tex> меньше ключей в <tex>T'</tex>, поэтому мы можем это сделать). Теперь в дереве <tex>T_{1}</tex> у отца вершины, в которой мы остановились при поиске дерева <tex>P</tex>, правым поддеревом делаем дерево <tex>K</tex> и запускаем балансировку. После нужно спуститься в правое поддерево бывшего дерева <tex>S</tex> (по ссылке, которую мы ранее запомнили) и обработать его.

Если мы пришли в поддерево <tex>Q</tex>, корень которого <tex>> x</tex>, совершаем аналогичные действия: делаем NULL'ами ссылки на корень <tex>Q</tex>, запоминая ссылку на его левое поддерево. Делаем новую вершину со значением бывшего корня левым листом самой левой вершины <tex>Q</tex> и запускаем балансировку. Объединяем полученное АВЛ-дерево с уже построенным ранее <tex>T_{2}</tex> аналогичным первому случаю способом, только теперь мы ищем самое левое поддерево <tex>T_{2}</tex>.

Рассмотри пример (рис. 1). Цветом выделены поддеревья, которые после разделения должны отойти в дерево <tex>T_{1}</tex>. <tex>x = 76</tex>.

{| cellpadding="2"
| || [[Файл:AVL.jpg|thumb|left|525px|Рис. 1. Разделение АВЛ-дерева на два.]]
|}

Корень дерева <tex>\leqslant x</tex>, поэтому он со всем выделенным поддеревом должен отойти в дерево <tex>T_{1}</tex>. По описанному выше алгоритму отделяем это поддерево с корнем и делаем из них сбалансированное АВЛ-дерево <tex>T'</tex> (рис. 2). Так как это первая ситуация, в которой корень рассматриваемого поддерева был <tex>\leqslant x</tex>, <tex>T'</tex> становится <tex>T_{1}</tex>. Далее по сохраненной ссылке спускаемся в правое поддерево. Его корень <tex>> x</tex>. Следовательно, строим из него и его правого поддерева <tex>T_{2}</tex> и спускаемся в левое поддерево. Снова корень <tex>\leqslant x</tex>. Строим новое <tex>T'</tex> и объединяем его с уже существующим <tex>T_{1}</tex> (рис. 3).

{| cellpadding="2"
| || [[Файл:АВВЛ2.jpg|thumb|left|525px|Рис. 2. Создание T'.]]
|}
{| cellpadding="2"
| || [[Файл:AVL3.jpg|thumb|left|1050px|Рис. 3. Объединение T' и T1.]]
|}

Далее действуем по алгоритму и в итоге получаем (рис. 4):

{| cellpadding="2"
| || [[Файл:End.jpg|thumb|left|525px|Рис. 4. АВЛ-деревья после разделения.]]
|}

Данный алгоритм имеет сложность <tex>O(\log^{2} n)</tex>.

====Алгоритм второй====
Рассмотрим решение, которое имеет сложность <tex>O(\log{n})</tex>.

Вернемся к примеру (рис. 1). Теперь рекурсивно спустимся вниз и оттуда будем строить деревья <tex>T_{1}</tex> и <tex>T_{2}</tex>, передавая наверх корректные АВЛ-деревья. То есть для рис. 1 первым в дерево <tex>T_{1}</tex> придет вершина <tex>75</tex> с левым поддеревом (выделено светло-зеленым цветом), так как это корректное АВЛ-дерево, оно же и вернется из рекурсии. Далее мы попадем в вершину со значением <tex>70</tex> и должны слить ее и ее левое поддерево (выделено светло-синим) с тем, что нам пришло. И сделать это нужно так, чтобы передать наверх корректное АВЛ-дерево. Будем действовать по такому алгоритму, пока не дойдем до вершины.

Пусть мы пришли в поддерево <tex>S</tex> с корнем <tex>\leqslant x</tex>. Тогда сольем его с уже построенным на тот момент <tex>T_{1}</tex> (<tex>T_{1}</tex> пришло снизу, а значит по условию рекурсии это корректное АВЛ-дерево, <tex>S \leqslant T_{1}</tex> и <tex>h(T_{1}) \leqslant h(S)</tex>). Но так как обычная процедура слияния сливает два АВЛ-дерева, а <tex>S</tex> не является корректным АВЛ-деревом, мы немного ее изменим. Пусть мы в дереве <tex>S</tex> нашли самое правое поддерево <tex>K</tex>, высота которого равна высоте <tex>T_{1}</tex>. Тогда сделаем новое дерево <tex>T'</tex>, корнем которого будет вершина <tex>S</tex> (без нее это дерево является сбалансированным), правым поддеревом {{---}} <tex>T_{1}</tex>, левым {{---}} <tex>K</tex>. И подвесим <tex>T'</tex> на то место, где мы остановились при поиске <tex>K</tex>. Запустим балансировку. В случае, когда корень поддерева, в которое мы пришли, <tex>> x</tex>, все аналогично.

Разберем пример на рис. 1. Пусть мы рекурсивно спустились до узла <tex>77</tex>. Ключ больше <tex>x</tex>, поэтому эта вершина станет деревом <tex>T_{2}</tex> и передастся наверх. Теперь мы поднялись в узел <tex>75</tex>. Он со своим левым поддеревом станет деревом <tex>T_{1}</tex> и мы снова поднимемся наверх в узел <tex>70</tex>. Он со своим левым поддеревом снова должен отойти в дерево <tex>T_{1}</tex>, и так как теперь дерево <tex>T_{1}</tex> уже не пустое, то их надо слить. После слияния по описанному выше алгоритму получим (рис. 5)

{| cellpadding="2"
| || [[Файл:Ex.jpg|thumb|left|525px|Рис. 5.]]
|}

После мы поднимемся в вершину с ключом <tex>80</tex>. Она с правым поддеревом отойдет в дерево <tex>T_{2}</tex> (рис. 6).

{| cellpadding="2"
| || [[Файл:Ex2am.jpg|thumb|left|525px|Рис. 6.]]
|}

И на последней итерации мы поднимемся в корень дерева с ключом <tex>50</tex>, он с левым поддеревом отойдет в дерево <tex>T_{1}</tex>, после чего алгоритм завершится.

Пусть поддеревьев с ключами <tex>\leqslant x</tex> оказалось больше, чем поддеревьев с ключами <tex>> x</tex>. Докажем для них логарифмическую асимптотику. Дерево на последнем уровне имеет высоту <tex>H_{k}</tex> (она может быть не равна <tex>1</tex>, если мы придём в <tex>x</tex>). Его мы передаем наверх и вставляем в поддерево высотой <tex>H_{k-1}</tex>. <tex>H_{k} \leqslant H_{k-1}</tex>, так как разница высот поддеревьев у любой вершины не больше <tex>1</tex>, и мы при переходе от <tex>H_{k}</tex> к <tex>H_{k-1}</tex> поднимаемся как минимум на одну вершину вверх. Слияние этих поддеревьев мы выполним за <tex>H_{k-1} - H_{k}</tex>, получим в итоге дерево высоты не большей, чем <tex>H_{k-1}</tex>. Его мы передадим наверх, поэтому в следующий раз слияние будет выполнено за <tex>H_{k-2} - H_{k - 1}</tex> и так далее. Таким образом мы получим <tex>(H - H_{1}) + (H_{1} - H_{2}) + (H_{2} - H_{3}) + \cdots + (H_{k - 1} - H_{k}) = H - H_{k} = O(\log{n})</tex>.

Итоговая асимптотика алгоритма {{---}} <tex>O(\log{n})</tex>.

== См. также ==
* [[Splay-дерево]]
* [[Красно-черное дерево]]
* [[2-3 дерево]]

== Источники информации ==
* [http://habrahabr.ru/post/150732/ Habrahabr {{---}} АВЛ-деревья]
* [http://ru.wikipedia.org/wiki/АВЛ-дерево Википедия {{---}} АВЛ-дерево]

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Деревья поиска]]
[[Категория:Структуры данных]]

АВЛ-дерево

2015-06-05T18:07:04Z

Паршуков Кирилл: /* Балансировка */

'''АВЛ-дерево''' (англ. ''AVL-Tree'') {{---}} сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором поддерживается следующее свойство: для каждой его вершины высота её двух поддеревьев различается не более чем на 1.

АВЛ-деревья названы по первым буквам фамилий их изобретателей, Г. М. Адельсона-Вельского и Е. М. Ландиса, которые впервые предложили использовать АВЛ-деревья в 1962 году.

== Высота дерева ==
{{Теорема
|statement=АВЛ-дерево с <tex>n</tex> ключами имеет высоту <tex>h = O(\log N)</tex>.
||proof=

Высоту поддерева с корнем <tex>x</tex> будем обозначать как <tex>h(x)</tex>, высоту поддерева <tex>T</tex> {{---}} как <tex>h(T)</tex>.

{{Лемма
|statement= Пусть <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>, тогда <tex>m_h = F_{h+2} - 1</tex>, где <tex>F_h - h</tex>-ое число Фибоначчи.
|proof=
Если <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>. Тогда, как легко видеть, <tex>m_{h+2} = m_{h+1} + m_h + 1</tex>. Равенство <tex>m_h = F_{h+2} - 1</tex> докажем по индукции.

База индукции <tex>m_1 = F_3 - 1</tex> {{---}} верно, <tex>m_1 = 1, F_3 = 2</tex>.

Допустим <tex>m_h = F_{h+2} - 1</tex> {{---}} верно.

Тогда <tex>m_{h+1} = m_h + m_{h-1} + 1 = F_{h+2} - 1 + F_{h+1} - 1 + 1 = F_{h+3} - 1</tex>.

Таким образом, равенство <tex>m_h = F_{h+2} - 1</tex> {{---}} доказано.
}}

<tex>F_h = \Omega(\varphi^h)</tex>, <tex>\varphi = \dfrac{ \sqrt{5}+1}{2}</tex>. То есть

<tex>n \geqslant \varphi^{h}</tex>

Логарифмируя по основанию <tex>\varphi</tex>, получаем

<tex>\log_{\varphi}n \geqslant h</tex>

Таким образом, получаем, что высота AVL-дерева из n вершин {{---}} <tex>O(\log{n})</tex>.
}}

== Балансировка ==
'''Балансировкой вершины''' называется операция, которая в случае разницы высот левого и правого поддеревьев <tex>|h(L) - h(R)| = 2</tex>, изменяет связи предок-потомок в поддереве данной вершины так, чтобы восстановилось свойство дерева <tex>|h(L) - h(R)| \leqslant 1</tex>, иначе ничего не меняет.
Для балансировки будем хранить для каждой вершины разницу между высотой её левого и правого поддерева <tex>diff[i] = h(L) - h(R)</tex>

Для балансировки вершины используются один из 4 типов вращений:

{| border="1" cellpadding="5" cellspacing="0"
!Тип вращения
!Иллюстрация
!Когда используется
!Расстановка балансов
|-
|'''Малое левое вращение'''
| [[Файл:avl_u1.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> и <tex>diff[b] = -1</tex>

или

<tex>diff[a] = -2</tex> и <tex>diff[b] = 0</tex>.
|

<tex>diff[a] = 0</tex> и <tex>diff[b] = 0</tex>

<tex>diff[a] = -1</tex> и <tex>diff[b] = 1</tex>
|-
|'''Большое левое вращение'''
| [[Файл:avl_u2.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> , <tex>diff[b] = 1</tex> и <tex>diff[c] = 1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = -1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = 0</tex>.
|

<tex>diff[a] = 0</tex>, <tex>diff[b] = -1</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 1</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 0</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>
|}
Малый левый поворот:
'''function''' rotateleft(Node a):
node b = a.right
a.right = b.left
b.left = a
fixheight(a)
fixheight(b)

Большой правый поворот пишется проще:
'''function''' bigrotateleft(node a):
rotateright(a.right)
rotateleft(a)

Малое правое и большое правое вращение определяются симметрично малому левому и большому левому вращению.
В каждом случае операция приводит к нужному результату, а полная высота уменьшается не более чем на <tex>1</tex> и не может увеличиться.

Все операции вращения, очевидно, требуют <tex>O(1)</tex> операций.

== Операции ==
=== Добавление вершины ===
Пусть нам надо добавить ключ <tex>t</tex>. Будем спускаться по дереву, как при поиске ключа <tex>t</tex>. Если мы стоим в вершине <tex>a</tex> и нам надо идти в поддерево, которого нет, то делаем ключ <tex>t</tex> листом, а вершину <tex>a</tex> его корнем. Дальше поднимаемся вверх по пути поиска и пересчитываем баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> увеличивается на единицу, если из правого, то уменьшается на единицу. Если пришли в вершину и её баланс стал равным нулю, то это значит высота поддерева не изменилась и подъём останавливается. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит высота поддерева изменилась и подъём продолжается. Если пришли в вершину и её баланс стал равным <tex>2</tex> или <tex>-2</tex>, то делаем одно из четырёх вращений и, если после вращения баланс стал равным нулю, то останавливаемся, иначе продолжаем подъём.

Так как в процессе добавления вершины мы рассматриваем не более, чем <tex> O(h) </tex> вершин дерева, и для каждой запускаем балансировку не более одного раза, то суммарное количество операций при включении новой вершины в дерево составляет <tex> O(\log{n}) </tex> операций.

=== Удаление вершины ===
Для простоты опишем рекурсивный алгоритм удаления.
Если вершина {{---}} лист, то [[Дерево поиска, наивная реализация#Удаление|удалим]] её, иначе найдём самую близкую по значению вершину <tex>a</tex>, переместим её на место удаляемой вершины и [[Дерево поиска, наивная реализация#Удаление|удалим]] вершину <tex>a</tex>. От удалённой вершины будем подниматься вверх к корню и пересчитывать баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> уменьшается на единицу, если из правого, то увеличивается на единицу. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит, что высота этого поддерева не изменилась и подъём можно остановить. Если баланс вершины стал равным нулю, то высота поддерева уменьшилась и подъём нужно продолжить. Если баланс стал равным <tex>2</tex> или <tex>-2</tex>, следует выполнить одно из четырёх вращений и, если после вращений баланс вершины стал равным нулю, то подъём продолжается, иначе останавливается.

В результате указанных действий на удаление вершины и балансировку суммарно тратится, как и ранее, <tex> O(h) </tex> операций. Таким образом, требуемое количество действий {{---}} <tex> O(\log{n}) </tex>.

=== Поиск вершины, минимум/максимум в дереве, etc. ===
Остальные операции не меняют структуры дерева, поэтому выполняются так же, как и в [[Дерево поиска, наивная реализация|наивной реализации]] дерева поиска.
===Слияние двух AVL-деревьев===

Дано два дерева <tex>T_1</tex> и <tex>T_2</tex>, все ключи в <tex>T_1</tex> меньше ключей в <tex>T_2</tex>, <tex>h(T_1) \leqslant h(T_2)</tex>.

В дереве <tex>T_1</tex> удаляем самую правую вершину, назовём её <tex>b</tex>. Высота дерева <tex>T_1</tex> может уменьшиться на единицу. В дереве <tex>T_2</tex> идём от корня всегда в левое поддерево и, когда высота этого поддерева <tex>P</tex> будет равна высоте дерева <tex>T_1</tex>, делаем новое дерево <tex>S</tex>, корнем <tex>S</tex> будет вершина <tex>b</tex>, левым поддеревом будет дерево <tex>T_1</tex>, а правым дерево <tex>P</tex>. Теперь в дереве <tex>T_2</tex> у вершины, в которой мы остановились при спуске, левым поддеревом делаем дерево <tex>S</tex> и запускаем балансировку. Таким образом, дерево <tex>T_2</tex> будет результатом слияния двух АВЛ-деревьев.

Дерево <tex>T_1</tex> и <tex>T_2</tex> до слияния

[[File:avl_u3.jpg|340px]]

Дерево <tex>T_2</tex> после слияния

[[File:avl_u4.jpg|300px]]

===Алгоритм разделения AVL-дерева на два===
====Алгоритм первый====
Пусть у нас есть дерево <tex>T</tex>. Мы должны разбить его на два дерева <tex>T_{1}</tex> и <tex>T_{2}</tex> такие, что <tex>T_{1} \leqslant x</tex> и <tex>x < T_{2}</tex>.

Предположим, что корень нашего дерева <tex>\leqslant x</tex>, в таком случае все левое поддерево вместе с корнем после разделения отойдет в дерево <tex>T_{1}</tex>. Тогда рекурсивно спускаемся в правое поддерево и там проверяем это условие (так как часть правого поддерева тоже может содержать ключи <tex>\leqslant x</tex>). Если же корень оказался <tex>> x</tex>, то мы спускаемся той же рекурсией, но только в левое поддерево и ищем там.

Пусть мы пришли в поддерево <tex>S</tex>, корень которого <tex>\leqslant x</tex>. В таком случае этот корень со своим левым поддеревом должен отойти в дерево <tex>T_{1}</tex>. Поэтому мы делаем следующее: запоминаем ссылку на правое поддерево <tex>S</tex>, удаляем корень, запоминая его значение (не меняя конфигурацию дерева, то есть просто делаем ссылки на него NULL'ами). Таким образом, мы отделяем сбалансированное АВЛ-дерево (бывшее левое поддерево <tex>S</tex>). Делаем новую вершину со значением бывшего корня правым листом самой правой вершины <tex>S</tex> и запускаем балансировку. Обозначим полученное дерево за <tex>T'</tex>. Теперь нам нужно объединить его с уже построенным ранее <tex>T_{1}</tex> (оно может быть пустым, если мы первый раз нашли такое дерево <tex>S</tex>). Для этого мы ищем в дереве <tex>T_{1}</tex> самое правое поддерево <tex>P</tex> высоты, равной высоте <tex>T'</tex> (спускаясь от корня всегда в правые поддеревья). Делаем новое дерево <tex>K</tex>, сливая <tex>P</tex> и <tex>T'</tex> (очевидно, все ключи в <tex>T_{1}</tex> меньше ключей в <tex>T'</tex>, поэтому мы можем это сделать). Теперь в дереве <tex>T_{1}</tex> у отца вершины, в которой мы остановились при поиске дерева <tex>P</tex>, правым поддеревом делаем дерево <tex>K</tex> и запускаем балансировку. После нужно спуститься в правое поддерево бывшего дерева <tex>S</tex> (по ссылке, которую мы ранее запомнили) и обработать его.

Если мы пришли в поддерево <tex>Q</tex>, корень которого <tex>> x</tex>, совершаем аналогичные действия: делаем NULL'ами ссылки на корень <tex>Q</tex>, запоминая ссылку на его левое поддерево. Делаем новую вершину со значением бывшего корня левым листом самой левой вершины <tex>Q</tex> и запускаем балансировку. Объединяем полученное АВЛ-дерево с уже построенным ранее <tex>T_{2}</tex> аналогичным первому случаю способом, только теперь мы ищем самое левое поддерево <tex>T_{2}</tex>.

Рассмотри пример (рис. 1). Цветом выделены поддеревья, которые после разделения должны отойти в дерево <tex>T_{1}</tex>. <tex>x = 76</tex>.

{| cellpadding="2"
| || [[Файл:AVL.jpg|thumb|left|525px|Рис. 1. Разделение АВЛ-дерева на два.]]
|}

Корень дерева <tex>\leqslant x</tex>, поэтому он со всем выделенным поддеревом должен отойти в дерево <tex>T_{1}</tex>. По описанному выше алгоритму отделяем это поддерево с корнем и делаем из них сбалансированное АВЛ-дерево <tex>T'</tex> (рис. 2). Так как это первая ситуация, в которой корень рассматриваемого поддерева был <tex>\leqslant x</tex>, <tex>T'</tex> становится <tex>T_{1}</tex>. Далее по сохраненной ссылке спускаемся в правое поддерево. Его корень <tex>> x</tex>. Следовательно, строим из него и его правого поддерева <tex>T_{2}</tex> и спускаемся в левое поддерево. Снова корень <tex>\leqslant x</tex>. Строим новое <tex>T'</tex> и объединяем его с уже существующим <tex>T_{1}</tex> (рис. 3).

{| cellpadding="2"
| || [[Файл:АВВЛ2.jpg|thumb|left|525px|Рис. 2. Создание T'.]]
|}
{| cellpadding="2"
| || [[Файл:AVL3.jpg|thumb|left|1050px|Рис. 3. Объединение T' и T1.]]
|}

Далее действуем по алгоритму и в итоге получаем (рис. 4):

{| cellpadding="2"
| || [[Файл:End.jpg|thumb|left|525px|Рис. 4. АВЛ-деревья после разделения.]]
|}

Данный алгоритм имеет сложность <tex>O(\log^{2} n)</tex>.

====Алгоритм второй====
Рассмотрим решение, которое имеет сложность <tex>O(\log{n})</tex>.

Вернемся к примеру (рис. 1). Теперь рекурсивно спустимся вниз и оттуда будем строить деревья <tex>T_{1}</tex> и <tex>T_{2}</tex>, передавая наверх корректные АВЛ-деревья. То есть для рис. 1 первым в дерево <tex>T_{1}</tex> придет вершина <tex>75</tex> с левым поддеревом (выделено светло-зеленым цветом), так как это корректное АВЛ-дерево, оно же и вернется из рекурсии. Далее мы попадем в вершину со значением <tex>70</tex> и должны слить ее и ее левое поддерево (выделено светло-синим) с тем, что нам пришло. И сделать это нужно так, чтобы передать наверх корректное АВЛ-дерево. Будем действовать по такому алгоритму, пока не дойдем до вершины.

Пусть мы пришли в поддерево <tex>S</tex> с корнем <tex>\leqslant x</tex>. Тогда сольем его с уже построенным на тот момент <tex>T_{1}</tex> (<tex>T_{1}</tex> пришло снизу, а значит по условию рекурсии это корректное АВЛ-дерево, <tex>S \leqslant T_{1}</tex> и <tex>h(T_{1}) \leqslant h(S)</tex>). Но так как обычная процедура слияния сливает два АВЛ-дерева, а <tex>S</tex> не является корректным АВЛ-деревом, мы немного ее изменим. Пусть мы в дереве <tex>S</tex> нашли самое правое поддерево <tex>K</tex>, высота которого равна высоте <tex>T_{1}</tex>. Тогда сделаем новое дерево <tex>T'</tex>, корнем которого будет вершина <tex>S</tex> (без нее это дерево является сбалансированным), правым поддеревом {{---}} <tex>T_{1}</tex>, левым {{---}} <tex>K</tex>. И подвесим <tex>T'</tex> на то место, где мы остановились при поиске <tex>K</tex>. Запустим балансировку. В случае, когда корень поддерева, в которое мы пришли, <tex>> x</tex>, все аналогично.

Разберем пример на рис. 1. Пусть мы рекурсивно спустились до узла <tex>77</tex>. Ключ больше <tex>x</tex>, поэтому эта вершина станет деревом <tex>T_{2}</tex> и передастся наверх. Теперь мы поднялись в узел <tex>75</tex>. Он со своим левым поддеревом станет деревом <tex>T_{1}</tex> и мы снова поднимемся наверх в узел <tex>70</tex>. Он со своим левым поддеревом снова должен отойти в дерево <tex>T_{1}</tex>, и так как теперь дерево <tex>T_{1}</tex> уже не пустое, то их надо слить. После слияния по описанному выше алгоритму получим (рис. 5)

{| cellpadding="2"
| || [[Файл:Ex.jpg|thumb|left|525px|Рис. 5.]]
|}

После мы поднимемся в вершину с ключом <tex>80</tex>. Она с правым поддеревом отойдет в дерево <tex>T_{2}</tex> (рис. 6).

{| cellpadding="2"
| || [[Файл:Ex2am.jpg|thumb|left|525px|Рис. 6.]]
|}

И на последней итерации мы поднимемся в корень дерева с ключом <tex>50</tex>, он с левым поддеревом отойдет в дерево <tex>T_{1}</tex>, после чего алгоритм завершится.

Пусть поддеревьев с ключами <tex>\leqslant x</tex> оказалось больше, чем поддеревьев с ключами <tex>> x</tex>. Докажем для них логарифмическую асимптотику. Дерево на последнем уровне имеет высоту <tex>H_{k}</tex> (она может быть не равна <tex>1</tex>, если мы придём в <tex>x</tex>). Его мы передаем наверх и вставляем в поддерево высотой <tex>H_{k-1}</tex>. <tex>H_{k} \leqslant H_{k-1}</tex>, так как разница высот поддеревьев у любой вершины не больше <tex>1</tex>, и мы при переходе от <tex>H_{k}</tex> к <tex>H_{k-1}</tex> поднимаемся как минимум на одну вершину вверх. Слияние этих поддеревьев мы выполним за <tex>H_{k-1} - H_{k}</tex>, получим в итоге дерево высоты не большей, чем <tex>H_{k-1}</tex>. Его мы передадим наверх, поэтому в следующий раз слияние будет выполнено за <tex>H_{k-2} - H_{k - 1}</tex> и так далее. Таким образом мы получим <tex>(H - H_{1}) + (H_{1} - H_{2}) + (H_{2} - H_{3}) + \cdots + (H_{k - 1} - H_{k}) = H - H_{k} = O(\log{n})</tex>.

Итоговая асимптотика алгоритма {{---}} <tex>O(\log{n})</tex>.

== См. также ==
* [[Splay-дерево]]
* [[Красно-черное дерево]]
* [[2-3 дерево]]

== Источники информации ==
* [http://habrahabr.ru/post/150732/ Habrahabr {{---}} АВЛ-деревья]
* [http://ru.wikipedia.org/wiki/АВЛ-дерево Википедия {{---}} АВЛ-дерево]

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Деревья поиска]]
[[Категория:Структуры данных]]

Файл:Avl u2.jpg

2015-06-05T17:59:25Z

Паршуков Кирилл: загружена новая версия «Файл:Avl u2.jpg»

Файл:Avl u1.jpg

2015-06-05T17:44:17Z

Паршуков Кирилл: загружена новая версия «Файл:Avl u1.jpg»: Возврат к версии от 17:41, 5 июня 2015

Файл:Avl u1.jpg

2015-06-05T17:43:26Z

Паршуков Кирилл: загружена новая версия «Файл:Avl u1.jpg»

Файл:Avl u1.jpg

2015-06-05T17:41:58Z

Паршуков Кирилл: загружена новая версия «Файл:Avl u1.jpg»

АВЛ-дерево

2015-05-10T05:54:19Z

Паршуков Кирилл: /* Балансировка */

'''АВЛ-дерево''' (''AVL-Tree'') {{---}} сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором поддерживается следующее свойство: для каждой его вершины высота её двух поддеревьев различается не более чем на 1.

АВЛ-деревья названы по первым буквам фамилий их изобретателей, Г. М. Адельсона-Вельского и Е. М. Ландиса, которые впервые предложили использовать АВЛ-деревья в 1962 году.

== Высота дерева ==
{{Теорема
|statement=АВЛ-дерево с <tex>n</tex> ключами имеет высоту <tex>h = O(\log N)</tex>.
||proof=

Высоту поддерева с корнем <tex>x</tex> будем обозначать как <tex>h(x)</tex>, высоту поддерева <tex>T</tex> {{---}} как <tex>h(T)</tex>.

{{Лемма
|statement= Пусть <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>, тогда <tex>m_h = F_{h+2} - 1</tex>, где <tex>F_h - h</tex>-ое число Фибоначчи.
|proof=
Если <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>. Тогда, как легко видеть, <tex>m_{h+2} = m_{h+1} + m_h + 1</tex>. Равенство <tex>m_h = F_{h+2} - 1</tex> докажем по индукции.

База индукции <tex>m_1 = F_3 - 1</tex> {{---}} верно, <tex>m_1 = 1, F_3 = 2</tex>.

Допустим <tex>m_h = F_{h+2} - 1</tex> {{---}} верно.

Тогда <tex>m_{h+1} = m_h + m_{h-1} + 1 = F_{h+2} - 1 + F_{h+1} - 1 + 1 = F_{h+3} - 1</tex>.

Таким образом, равенство <tex>m_h = F_{h+2} - 1</tex> {{---}} доказано.
}}

<tex>F_h = \Omega(\varphi^h)</tex>, <tex>\varphi = \frac{ \sqrt{5}+1}{2}</tex>. То есть

<tex>n \geqslant \varphi^{h}</tex>

Логарифмируя по основанию <tex>\varphi</tex>, получаем

<tex>\log_{\varphi}n \geqslant h</tex>

Таким образом, получаем, что высота AVL-дерева из n вершин {{---}} <tex>O(\log{n})</tex>.
}}

== Балансировка ==
'''Балансировкой вершины''' называется операция, которая в случае разницы высот левого и правого поддеревьев <tex>|h(L) - h(R)| = 2</tex>, изменяет связи предок-потомок в поддереве данной вершины так, чтобы восстановилось свойство дерева <tex>|h(L) - h(R)| \leqslant 1</tex>, иначе ничего не меняет.
Для балансировки будем хранить для каждой вершины разницу между высотой её левого и правого поддерева <tex>diff[i] = h(L) - h(R)</tex>

Для балансировки вершины используются один из 4 типов вращений:

{| border="1" cellpadding="5" cellspacing="0"
!Тип вращения
!Иллюстрация
!Когда используется
!Расстановка балансов
|-
|'''Малое левое вращение''' (''Small left rotation'')
| [[Файл:avl_u1.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> и <tex>diff[b] = -1</tex>

или

<tex>diff[a] = -2</tex> и <tex>diff[b] = 0</tex>.
|

<tex>diff[a] = 0</tex> и <tex>diff[b] = 0</tex>

<tex>diff[a] = -1</tex> и <tex>diff[b] = 1</tex>

|-
|'''Большое левое вращение''' (Big left rotation'')
| [[Файл:avl_u2.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> , <tex>diff[b] = 1</tex> и <tex>diff[c] = 1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = -1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = 0</tex>.
|

<tex>diff[a] = 0</tex>, <tex>diff[b] = -1</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 1</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 0</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>

|}
Малое правое и большое правое вращение определяются симметрично малому левому и большому левому вращению.
В каждом случае операция приводит к нужному результату, а полная высота уменьшается не более чем на 1 и не может увеличиться.

Все операции вращения, очевидно, требуют <tex>O(1)</tex> операций.

== Операции ==
=== Добавление вершины ===
Пусть нам надо добавить ключ <tex>t</tex>. Будем спускаться по дереву, как при поиске ключа <tex>t</tex>. Если мы стоим в вершине <tex>a</tex> и нам надо идти в поддерево, которого нет, то делаем ключ <tex>t</tex> листом, а вершину <tex>a</tex> его корнем. Дальше поднимаемся вверх по пути поиска и пересчитываем баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> увеличивается на единицу, если из правого, то уменьшается на единицу. Если пришли в вершину и её баланс стал равным нулю, то это значит высота поддерева не изменилась и подъём останавливается. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит высота поддерева изменилась и подъём продолжается. Если пришли в вершину и её баланс стал равным <tex>2</tex> или <tex>-2</tex>, то делаем одно из четырёх вращений и, если после вращения баланс стал равным нулю, то останавливаемся, иначе продолжаем подъём.

Так как в процессе добавления вершины мы рассматриваем не более, чем <tex> O(h) </tex> вершин дерева, и для каждой запускаем балансировку не более одного раза, то суммарное количество операций при включении новой вершины в дерево составляет <tex> O(\log{n}) </tex> операций.

=== Удаление вершины ===
Для простоты опишем рекурсивный алгоритм удаления.
Если вершина - лист, то [[Дерево поиска, наивная реализация#Удаление|удалим]] её, иначе найдём самую близкую по значению вершину <tex>a</tex>, переместим её на место удаляемой вершины и [[Дерево поиска, наивная реализация#Удаление|удалим]] вершину <tex>a</tex>. От удалённой вершины будем подниматься вверх к корню и пересчитывать баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> уменьшается на единицу, если из правого, то увеличивается на единицу. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит, что высота этого поддерева не изменилась и подъём можно остановить. Если баланс вершины стал равным нулю, то высота поддерева уменьшилась и подъём нужно продолжить. Если баланс стал равным <tex>2</tex> или <tex>-2</tex>, следует выполнить одно из четырёх вращений и, если после вращений баланс вершины стал равным нулю, то подъём продолжается, иначе останавливается.

В результате указанных действий на удаление вершины и балансировку суммарно тратится, как и ранее, <tex> O(h) </tex> операций. Таким образом, требуемое количество действий {{---}} <tex> O(\log{n}) </tex>.

=== Поиск вершины, минимум/максимум в дереве, etc. ===
Остальные операции не меняют структуры дерева, поэтому выполняются так же, как и в [[Дерево поиска, наивная реализация|наивной реализации]] дерева поиска.
===Слияние двух AVL-деревьев===

Дано два дерева <tex>T_1</tex> и <tex>T_2</tex>, все ключи в <tex>T_1</tex> меньше ключей в <tex>T_2</tex>, <tex>h(T_1) \leqslant h(T_2)</tex>.

В дереве <tex>T_1</tex> удаляем самую правую вершину, назовём её <tex>b</tex>. Высота дерева <tex>T_1</tex> может уменьшиться на единицу. В дереве <tex>T_2</tex> идём от корня всегда в левое поддерево и, когда высота этого поддерева <tex>P</tex> будет равна высоте дерева <tex>T_1</tex>, делаем новое дерево <tex>S</tex>, корнем <tex>S</tex> будет вершина <tex>b</tex>, левым поддеревом будет дерево <tex>T_1</tex>, а правым дерево <tex>P</tex>. Теперь в дереве <tex>T_2</tex> у вершины, в которой мы остановились при спуске, левым поддеревом делаем дерево <tex>S</tex> и запускаем балансировку. Таким образом, дерево <tex>T_2</tex> будет результатом слияния двух АВЛ-деревьев.

Дерево <tex>T_1</tex> и <tex>T_2</tex> до слияния

[[File:avl_u3.jpg|340px]]

Дерево <tex>T_2</tex> после слияния

[[File:avl_u4.jpg|300px]]

== Ссылки ==
* [http://habrahabr.ru/post/150732/ Habrahabr {{---}} АВЛ-деревья]
== Источники информации ==
* [http://ru.wikipedia.org/wiki/АВЛ-дерево Википедия {{---}} АВЛ-дерево]

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Деревья поиска]]

АВЛ-дерево

2015-05-10T05:53:41Z

Паршуков Кирилл:

'''АВЛ-дерево''' (''AVL-Tree'') {{---}} сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором поддерживается следующее свойство: для каждой его вершины высота её двух поддеревьев различается не более чем на 1.

АВЛ-деревья названы по первым буквам фамилий их изобретателей, Г. М. Адельсона-Вельского и Е. М. Ландиса, которые впервые предложили использовать АВЛ-деревья в 1962 году.

== Высота дерева ==
{{Теорема
|statement=АВЛ-дерево с <tex>n</tex> ключами имеет высоту <tex>h = O(\log N)</tex>.
||proof=

Высоту поддерева с корнем <tex>x</tex> будем обозначать как <tex>h(x)</tex>, высоту поддерева <tex>T</tex> {{---}} как <tex>h(T)</tex>.

{{Лемма
|statement= Пусть <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>, тогда <tex>m_h = F_{h+2} - 1</tex>, где <tex>F_h - h</tex>-ое число Фибоначчи.
|proof=
Если <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>. Тогда, как легко видеть, <tex>m_{h+2} = m_{h+1} + m_h + 1</tex>. Равенство <tex>m_h = F_{h+2} - 1</tex> докажем по индукции.

База индукции <tex>m_1 = F_3 - 1</tex> {{---}} верно, <tex>m_1 = 1, F_3 = 2</tex>.

Допустим <tex>m_h = F_{h+2} - 1</tex> {{---}} верно.

Тогда <tex>m_{h+1} = m_h + m_{h-1} + 1 = F_{h+2} - 1 + F_{h+1} - 1 + 1 = F_{h+3} - 1</tex>.

Таким образом, равенство <tex>m_h = F_{h+2} - 1</tex> {{---}} доказано.
}}

<tex>F_h = \Omega(\varphi^h)</tex>, <tex>\varphi = \frac{ \sqrt{5}+1}{2}</tex>. То есть

<tex>n \geqslant \varphi^{h}</tex>

Логарифмируя по основанию <tex>\varphi</tex>, получаем

<tex>\log_{\varphi}n \geqslant h</tex>

Таким образом, получаем, что высота AVL-дерева из n вершин {{---}} <tex>O(\log{n})</tex>.
}}

== Балансировка ==
'''Балансировкой вершины''' ('' называется операция, которая в случае разницы высот левого и правого поддеревьев <tex>|h(L) - h(R)| = 2</tex>, изменяет связи предок-потомок в поддереве данной вершины так, чтобы восстановилось свойство дерева <tex>|h(L) - h(R)| \leqslant 1</tex>, иначе ничего не меняет.
Для балансировки будем хранить для каждой вершины разницу между высотой её левого и правого поддерева <tex>diff[i] = h(L) - h(R)</tex>

Для балансировки вершины используются один из 4 типов вращений:

{| border="1" cellpadding="5" cellspacing="0"
!Тип вращения
!Иллюстрация
!Когда используется
!Расстановка балансов
|-
|'''Малое левое вращение''' (''Small left rotation'')
| [[Файл:avl_u1.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> и <tex>diff[b] = -1</tex>

или

<tex>diff[a] = -2</tex> и <tex>diff[b] = 0</tex>.
|

<tex>diff[a] = 0</tex> и <tex>diff[b] = 0</tex>

<tex>diff[a] = -1</tex> и <tex>diff[b] = 1</tex>

|-
|'''Большое левое вращение''' (Big left rotation'')
| [[Файл:avl_u2.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> , <tex>diff[b] = 1</tex> и <tex>diff[c] = 1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = -1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = 0</tex>.
|

<tex>diff[a] = 0</tex>, <tex>diff[b] = -1</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 1</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 0</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>

|}
Малое правое и большое правое вращение определяются симметрично малому левому и большому левому вращению.
В каждом случае операция приводит к нужному результату, а полная высота уменьшается не более чем на 1 и не может увеличиться.

Все операции вращения, очевидно, требуют <tex>O(1)</tex> операций.

== Операции ==
=== Добавление вершины ===
Пусть нам надо добавить ключ <tex>t</tex>. Будем спускаться по дереву, как при поиске ключа <tex>t</tex>. Если мы стоим в вершине <tex>a</tex> и нам надо идти в поддерево, которого нет, то делаем ключ <tex>t</tex> листом, а вершину <tex>a</tex> его корнем. Дальше поднимаемся вверх по пути поиска и пересчитываем баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> увеличивается на единицу, если из правого, то уменьшается на единицу. Если пришли в вершину и её баланс стал равным нулю, то это значит высота поддерева не изменилась и подъём останавливается. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит высота поддерева изменилась и подъём продолжается. Если пришли в вершину и её баланс стал равным <tex>2</tex> или <tex>-2</tex>, то делаем одно из четырёх вращений и, если после вращения баланс стал равным нулю, то останавливаемся, иначе продолжаем подъём.

Так как в процессе добавления вершины мы рассматриваем не более, чем <tex> O(h) </tex> вершин дерева, и для каждой запускаем балансировку не более одного раза, то суммарное количество операций при включении новой вершины в дерево составляет <tex> O(\log{n}) </tex> операций.

=== Удаление вершины ===
Для простоты опишем рекурсивный алгоритм удаления.
Если вершина - лист, то [[Дерево поиска, наивная реализация#Удаление|удалим]] её, иначе найдём самую близкую по значению вершину <tex>a</tex>, переместим её на место удаляемой вершины и [[Дерево поиска, наивная реализация#Удаление|удалим]] вершину <tex>a</tex>. От удалённой вершины будем подниматься вверх к корню и пересчитывать баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> уменьшается на единицу, если из правого, то увеличивается на единицу. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит, что высота этого поддерева не изменилась и подъём можно остановить. Если баланс вершины стал равным нулю, то высота поддерева уменьшилась и подъём нужно продолжить. Если баланс стал равным <tex>2</tex> или <tex>-2</tex>, следует выполнить одно из четырёх вращений и, если после вращений баланс вершины стал равным нулю, то подъём продолжается, иначе останавливается.

В результате указанных действий на удаление вершины и балансировку суммарно тратится, как и ранее, <tex> O(h) </tex> операций. Таким образом, требуемое количество действий {{---}} <tex> O(\log{n}) </tex>.

=== Поиск вершины, минимум/максимум в дереве, etc. ===
Остальные операции не меняют структуры дерева, поэтому выполняются так же, как и в [[Дерево поиска, наивная реализация|наивной реализации]] дерева поиска.
===Слияние двух AVL-деревьев===

Дано два дерева <tex>T_1</tex> и <tex>T_2</tex>, все ключи в <tex>T_1</tex> меньше ключей в <tex>T_2</tex>, <tex>h(T_1) \leqslant h(T_2)</tex>.

В дереве <tex>T_1</tex> удаляем самую правую вершину, назовём её <tex>b</tex>. Высота дерева <tex>T_1</tex> может уменьшиться на единицу. В дереве <tex>T_2</tex> идём от корня всегда в левое поддерево и, когда высота этого поддерева <tex>P</tex> будет равна высоте дерева <tex>T_1</tex>, делаем новое дерево <tex>S</tex>, корнем <tex>S</tex> будет вершина <tex>b</tex>, левым поддеревом будет дерево <tex>T_1</tex>, а правым дерево <tex>P</tex>. Теперь в дереве <tex>T_2</tex> у вершины, в которой мы остановились при спуске, левым поддеревом делаем дерево <tex>S</tex> и запускаем балансировку. Таким образом, дерево <tex>T_2</tex> будет результатом слияния двух АВЛ-деревьев.

Дерево <tex>T_1</tex> и <tex>T_2</tex> до слияния

[[File:avl_u3.jpg|340px]]

Дерево <tex>T_2</tex> после слияния

[[File:avl_u4.jpg|300px]]

== Ссылки ==
* [http://habrahabr.ru/post/150732/ Habrahabr {{---}} АВЛ-деревья]
== Источники информации ==
* [http://ru.wikipedia.org/wiki/АВЛ-дерево Википедия {{---}} АВЛ-дерево]

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Деревья поиска]]

АВЛ-дерево

2015-05-10T05:46:15Z

Паршуков Кирилл:

'''АВЛ-дерево''' {{---}} сбалансированное [[Дерево поиска, наивная реализация|двоичное дерево поиска]], в котором поддерживается следующее свойство: для каждой его вершины высота её двух поддеревьев различается не более чем на 1.

АВЛ-деревья названы по первым буквам фамилий их изобретателей, Г. М. Адельсона-Вельского и Е. М. Ландиса, которые впервые предложили использовать АВЛ-деревья в 1962 году.

== Высота дерева ==
{{Теорема
|statement=АВЛ-дерево с <tex>n</tex> ключами имеет высоту <tex>h = O(\log N)</tex>.
||proof=

Высоту поддерева с корнем <tex>x</tex> будем обозначать как <tex>h(x)</tex>, высоту поддерева <tex>T</tex> {{---}} как <tex>h(T)</tex>.

{{Лемма
|statement= Пусть <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>, тогда <tex>m_h = F_{h+2} - 1</tex>, где <tex>F_h - h</tex>-ое число Фибоначчи.
|proof=
Если <tex>m_h</tex> {{---}} минимальное число вершин в AVL-дереве высоты <tex>h</tex>. Тогда, как легко видеть, <tex>m_{h+2} = m_{h+1} + m_h + 1</tex>. Равенство <tex>m_h = F_{h+2} - 1</tex> докажем по индукции.

База индукции <tex>m_1 = F_3 - 1</tex> {{---}} верно, <tex>m_1 = 1, F_3 = 2</tex>.

Допустим <tex>m_h = F_{h+2} - 1</tex> {{---}} верно.

Тогда <tex>m_{h+1} = m_h + m_{h-1} + 1 = F_{h+2} - 1 + F_{h+1} - 1 + 1 = F_{h+3} - 1</tex>.

Таким образом, равенство <tex>m_h = F_{h+2} - 1</tex> {{---}} доказано.
}}

<tex>F_h = \Omega(\varphi^h)</tex>, <tex>\varphi = \frac{ \sqrt{5}+1}{2}</tex>. То есть

<tex>n \geqslant \varphi^{h}</tex>

Логарифмируя по основанию <tex>\varphi</tex>, получаем

<tex>\log_{\varphi}n \geqslant h</tex>

Таким образом, получаем, что высота AVL-дерева из n вершин {{---}} <tex>O(\log{n})</tex>.
}}

== Балансировка ==
'''Балансировкой вершины''' называется операция, которая в случае разницы высот левого и правого поддеревьев <tex>|h(L) - h(R)| = 2</tex>, изменяет связи предок-потомок в поддереве данной вершины так, чтобы восстановилось свойство дерева <tex>|h(L) - h(R)| \leqslant 1</tex>, иначе ничего не меняет.
Для балансировки будем хранить для каждой вершины разницу между высотой её левого и правого поддерева <tex>diff[i] = h(L) - h(R)</tex>

Для балансировки вершины используются один из 4 типов вращений:

{| border="1" cellpadding="5" cellspacing="0"
!Тип вращения
!Иллюстрация
!Когда используется
!Расстановка балансов
|-
|'''Малое левое вращение'''
| [[Файл:avl_u1.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> и <tex>diff[b] = -1</tex>

или

<tex>diff[a] = -2</tex> и <tex>diff[b] = 0</tex>.
|

<tex>diff[a] = 0</tex> и <tex>diff[b] = 0</tex>

<tex>diff[a] = -1</tex> и <tex>diff[b] = 1</tex>

|-
|'''Большое левое вращение'''
| [[Файл:avl_u2.jpg|2000x200px]]
|
<tex>diff[a] = -2</tex> , <tex>diff[b] = 1</tex> и <tex>diff[c] = 1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = -1</tex>

или

<tex>diff[a] = -2</tex>, <tex>diff[b] = 1</tex> и <tex>diff[c] = 0</tex>.
|

<tex>diff[a] = 0</tex>, <tex>diff[b] = -1</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 1</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>

<tex>diff[a] = 0</tex>, <tex>diff[b] = 0</tex> и <tex>diff[c] = 0</tex>

|}
Малое правое и большое правое вращение определяются симметрично малому левому и большому левому вращению.
В каждом случае операция приводит к нужному результату, а полная высота уменьшается не более чем на 1 и не может увеличиться.

Все операции вращения, очевидно, требуют <tex>O(1)</tex> операций.

== Операции ==
=== Добавление вершины ===
Пусть нам надо добавить ключ <tex>t</tex>. Будем спускаться по дереву, как при поиске ключа <tex>t</tex>. Если мы стоим в вершине <tex>a</tex> и нам надо идти в поддерево, которого нет, то делаем ключ <tex>t</tex> листом, а вершину <tex>a</tex> его корнем. Дальше поднимаемся вверх по пути поиска и пересчитываем баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> увеличивается на единицу, если из правого, то уменьшается на единицу. Если пришли в вершину и её баланс стал равным нулю, то это значит высота поддерева не изменилась и подъём останавливается. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит высота поддерева изменилась и подъём продолжается. Если пришли в вершину и её баланс стал равным <tex>2</tex> или <tex>-2</tex>, то делаем одно из четырёх вращений и, если после вращения баланс стал равным нулю, то останавливаемся, иначе продолжаем подъём.

Так как в процессе добавления вершины мы рассматриваем не более, чем <tex> O(h) </tex> вершин дерева, и для каждой запускаем балансировку не более одного раза, то суммарное количество операций при включении новой вершины в дерево составляет <tex> O(\log{n}) </tex> операций.

=== Удаление вершины ===
Для простоты опишем рекурсивный алгоритм удаления.
Если вершина - лист, то [[Дерево поиска, наивная реализация#Удаление|удалим]] её, иначе найдём самую близкую по значению вершину <tex>a</tex>, переместим её на место удаляемой вершины и [[Дерево поиска, наивная реализация#Удаление|удалим]] вершину <tex>a</tex>. От удалённой вершины будем подниматься вверх к корню и пересчитывать баланс у вершин. Если мы поднялись в вершину <tex>i</tex> из левого поддерева, то <tex>diff[i]</tex> уменьшается на единицу, если из правого, то увеличивается на единицу. Если пришли в вершину и её баланс стал равным <tex>1</tex> или <tex>-1</tex>, то это значит, что высота этого поддерева не изменилась и подъём можно остановить. Если баланс вершины стал равным нулю, то высота поддерева уменьшилась и подъём нужно продолжить. Если баланс стал равным <tex>2</tex> или <tex>-2</tex>, следует выполнить одно из четырёх вращений и, если после вращений баланс вершины стал равным нулю, то подъём продолжается, иначе останавливается.

В результате указанных действий на удаление вершины и балансировку суммарно тратится, как и ранее, <tex> O(h) </tex> операций. Таким образом, требуемое количество действий {{---}} <tex> O(\log{n}) </tex>.

=== Поиск вершины, минимум/максимум в дереве, etc. ===
Остальные операции не меняют структуры дерева, поэтому выполняются так же, как и в [[Дерево поиска, наивная реализация|наивной реализации]] дерева поиска.
===Слияние двух AVL-деревьев===

Дано два дерева <tex>T_1</tex> и <tex>T_2</tex>, все ключи в <tex>T_1</tex> меньше ключей в <tex>T_2</tex>, <tex>h(T_1) \leqslant h(T_2)</tex>.

В дереве <tex>T_1</tex> удаляем самую правую вершину, назовём её <tex>b</tex>. Высота дерева <tex>T_1</tex> может уменьшиться на единицу. В дереве <tex>T_2</tex> идём от корня всегда в левое поддерево и, когда высота этого поддерева <tex>P</tex> будет равна высоте дерева <tex>T_1</tex>, делаем новое дерево <tex>S</tex>, корнем <tex>S</tex> будет вершина <tex>b</tex>, левым поддеревом будет дерево <tex>T_1</tex>, а правым дерево <tex>P</tex>. Теперь в дереве <tex>T_2</tex> у вершины, в которой мы остановились при спуске, левым поддеревом делаем дерево <tex>S</tex> и запускаем балансировку. Таким образом, дерево <tex>T_2</tex> будет результатом слияния двух АВЛ-деревьев.

Дерево <tex>T_1</tex> и <tex>T_2</tex> до слияния

[[File:avl_u3.jpg|340px]]

Дерево <tex>T_2</tex> после слияния

[[File:avl_u4.jpg|300px]]

== Ссылки ==
* [http://habrahabr.ru/post/150732/ Habrahabr {{---}} АВЛ-деревья]
== Источники информации ==
* [http://ru.wikipedia.org/wiki/АВЛ-дерево Википедия {{---}} АВЛ-дерево]

[[Категория:Дискретная математика и алгоритмы]]
[[Категория:Деревья поиска]]

Представление вещественных чисел

2015-01-12T19:25:06Z

Паршуков Кирилл:

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

Число с плавающей запятой состоит из набора отдельных двоичных разрядов, условно разделенных на так называемые '''знак''' (англ.'' sign''), '''порядок''' (англ. ''exponent'') и '''мантиссу''' (англ. ''mantis''). В наиболее распространённом формате (стандарт IEEE 754) число с плавающей запятой представляется в виде набора битов, часть из которых кодирует собой мантиссу числа, другая часть — показатель степени, и ещё один бит используется для указания знака числа (<tex>0</tex> {{---}} если число положительное, <tex>1</tex> {{---}} если число отрицательное). При этом порядок записывается как целое число в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|коде со сдвигом]], а мантисса {{---}} в [[#Нормальная и нормализованная форма|нормализованном виде]], своей дробной частью в двоичной системе счисления. Вот пример такого числа из <tex>16</tex> двоичных разрядов:
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=10 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0

!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Знак {{---}} один бит, указывающий знак всего числа с плавающей точкой. Порядок и мантисса — целые числа, которые вместе со знаком дают представление числа с плавающей запятой в следующем виде:

<tex>(-1)^S \times M \times B^E</tex>, где <tex>S</tex> {{---}} знак, <tex>B</tex> {{---}} основание, <tex>E</tex> {{---}} порядок, а <tex>M</tex> {{---}} мантисса.
Десятичное число, записываемое как <tex> ReE</tex>, где <tex>R</tex> {{---}} число в полуинтервале <tex>[1; 10)</tex>, <tex>E</tex> {{---}} степень, в которой стоит множитель <tex>10</tex>; в нормализированной форме модуль <tex>R</tex> будет являться мантиссой, а <tex>E</tex> {{---}} порядком, а <tex>S</tex> будет равно <tex>1</tex> тогда и только тогда, когда <tex>R</tex> принимает отрицательное значение.
Например, в числе <tex>-2435e9</tex>
* <tex>S</tex> <tex>=</tex> <tex>1</tex>
* <tex>B</tex> <tex>=</tex> <tex>10</tex>
* <tex>M</tex> <tex>=</tex> <tex>2435</tex>
* <tex>E</tex> <tex>=</tex> <tex>9</tex>

Порядок также иногда называют '''экспонентой''' или просто '''показателем степени'''.


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

Более простым вариантом представления вещественных чисел является вариант с фиксированной точкой, когда целая и вещественная части хранятся отдельно. Например, на целую часть отводится всегда <tex>X</tex> бит и на дробную отводится всегда <tex>Y</tex> бит. Такой способ в архитектурах процессоров не присутствует. Отдаётся предпочтение числам с плавающей запятой, как компромиссу между диапазоном допустимых значений и точностью.

== Нормальная и нормализованная форма ==

'''Нормальной формой''' (англ. ''normal form'') числа с плавающей запятой называется такая форма, в которой мантисса (без учёта знака) в десятичной системе находится на полуинтервале <tex>[0; 1)</tex>. Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, <tex>0{,}0001</tex> можно записать в 4 формах — <tex>0{,}0001</tex> \times <tex>10</tex><tex>0</tex>, <tex>0{,}001</tex> \times <tex>10</tex><tex>−1</tex>, <tex>0{,}01</tex> \times <tex>10</tex><tex>−2</tex>, <tex>0{,}1</tex> \times <tex>10</tex><tex>−3</tex>), поэтому распространена также другая форма записи — '''нормализованная''' (англ. ''normalized''), в которой мантисса десятичного числа принимает значения от <tex>1</tex> (включительно) до <tex>10</tex> (не включительно), а мантисса двоичного числа принимает значения от <tex>1</tex> (включительно) до <tex>2</tex> (не включительно). То есть в мантиссе слева от запятой до применения порядка находится ровно один знак. В такой форме любое число (кроме <tex>0</tex>) записывается единственным образом. Ноль же представить таким образом невозможно, поэтому стандарт предусматривает специальную последовательность битов для задания числа <tex>0</tex> (а заодно и некоторых других [[#Особые значения чисел с плавающей точкой|полезных чисел]], таких как <tex>-\infty</tex> и <tex>+\infty</tex>).
Так как старший двоичный разряд (целая часть) мантиссы вещественного числа в нормализованном виде всегда равен «<tex>1</tex>», то его можно не записывать, сэкономив таким образом один бит, что и используется в стандарте IEEE 754. В позиционных системах счисления с основанием большим, чем <tex>2</tex> (в троичной, четверичной и др.), этого замечательного свойства нет (ведь целая часть там может быть не только единицей).

== Типы чисел с плавающей точкой (по IEEE 754) ==
=== Число половинной точности (''Binary16'', ''Half precision'') ===

'''Число́ полови́нной то́чности''' — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — <tex>16</tex> бит или <tex>2</tex> байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=3 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=2 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=6 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|со сдвигом]] '''<tex>-15</tex>'''. То есть чтобы получить актуально значение порядка нужно вычесть из него сдвиг. Сдвиг можно получить по формуле <tex>2^{b-1}-1</tex>, где <tex>b</tex> {{---}} число бит, отведенное на хранение порядка (в случае числа половинной точности <tex>b=5</tex>).

'''Ограничения точности'''
* Целые от нуля до <tex>2048</tex> передаются как есть.
* Целые от <tex>2049</tex> до <tex>4096</tex> округляются к ближайшему чётному целому.
* Целые от <tex>4097</tex> до <tex>8192</tex> округляются до ближайшего целого, делящегося нацело на четыре.
* Целые от <tex>8193</tex> до <tex>16384</tex> округляются до ближайшего целого, делящегося на восемь.
* Целые от <tex>16385</tex> до <tex>32768</tex> округляются до ближайшего целого, делящегося на шестнадцать.
* Целые от <tex>32769</tex> до <tex>65535</tex> округляются до ближайшего целого, делящегося на тридцать два.

=== Число одинарной точности (''Binary32'', ''Single precision'', ''float'') ===

'''Число́ одина́рной то́чности''' — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — <tex>32</tex> бита или <tex>4</tex> байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.

{|class="wikitable" style="background-color: transparent; border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=8 style="background-color: lightgreen; border: thin solid black"|Порядок (8 бит)
!colspan=24 style="background-color: lightcoral; border: thin solid black"|Мантисса (23+1 бита)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"|
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|30
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|23
|style="border: none"|
|colspan=20 style="border: none; border-left: 1px solid gray; text-align: left"|22
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-127</tex>'''.

=== Число двойной точности (''Binary64'', ''Double precision'', ''double'') ===

'''Число́ двойно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — <tex>64</tex> бита или <tex>8</tex> байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=11 style="background-color: lightgreen; border: thin solid black"|Порядок (11 бит)
!colspan=53 style="background-color: lightcoral; border: thin solid black"|Мантисса (52+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|62
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|52
|style="border: none"|
|colspan=48 style="border: none; border-left: 1px solid gray; text-align: left"|51
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-1023</tex>'''.

=== Число четверной точности (''Binary128'', ''Quadruple precision'') ===

'''Число́ четверно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — <tex>128</tex> бит или <tex>16</tex> байт). Используется в случае необходимости крайне высокой точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=15 style="background-color: lightgreen; border: thin solid black"|Порядок (15 бит)
!colspan=47 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=8 style="border: none; border-left: 1px solid gray; text-align: left"|126
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|112
|style="border: none"|
|colspan=38 style="border: none; border-left: 1px solid gray; text-align: left"|111
|}
 
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=66 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|colspan=66 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-16383</tex>'''.

Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки. Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью).
В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.

=== Диапазон значений чисел с плавающей запятой ===
Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, "не число", получается как результат операций типа деления нуля на ноль) и <tex>\pm\infty</tex>.

Данная таблица только лишь примерно указывает границы допустимых значений, без учета возрастающей погрешности с ростом абсолютного значения и существования [[#Денормализованные числа|денормализованных чисел]].


{| class="wikitable"
!Название в IEEE 754|| Название типа переменной в Си || Диапазон значений || Бит в мантиссе || Бит на переменную
|-
|Half precision||-||6,10×10-5..65504||11||16
|-
|Single presicion||float||3,4×10-38..3,4×1038||23||32
|-
|Double precision||double||1,7×10-308..1,7×10308||53||64
|-
|Extended precision||На некоторых архитектурах (например в сопроцессоре Intel) long double||3,4×10-4932..3,4×104932||65||80
|}

== Особые значения чисел с плавающей точкой ==
=== Ноль (со знаком) ===
Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль. Поэтому для его представления зарезервированы специальные значения мантиссы и порядка {{---}} число считается нулём, если все его биты, кроме знакового, равны нулю. При этом в зависимости от значения бита знака ноль может быть как положительным, так и отрицательным.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm0</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

'''Арифметика нуля со знаком'''
 
Арифметика отрицательного нуля аналогична таковой для любого отрицательного числа и понятна интуитивно. Вот несколько примеров:

* <tex>\frac{-0}{ \left| x \right| } = -0\,\!</tex> (если <tex>x\ne0</tex>)

* <tex>(-0) \cdot (-0) = +0\,\!</tex>

* <tex>\left| x \right| \cdot (-0) = -0\,\!</tex>

* <tex>x + (\pm 0) = x\,\!</tex>

* <tex>(-0) + (-0) = -0\,\!</tex>

* <tex>(+0) + (+0) = +0\,\!</tex>

* <tex>\frac{-0}{-\infty} = +0\,\!</tex>

* <tex>\frac{\left|x\right|}{-0} = -\infty\,\!</tex> (если <tex>x\ne0</tex>)

=== Неопределенность (''NaN'') ===
'''NaN''' {{---}} это аббревиатура от фразы "''not a number''". NaN является результатом арифметических операций, если во время их выполнения произошла ошибка (примеры см. ниже). В IEEE 754 NaN представлен как число, в котором все двоичные разряды порядка {{---}} единицы, а мантисса не нулевая.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: transparent; border: none"| = <tex>NaN</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.

'''Как можно получить NaN?'''
 

* <tex>\infty+(-\infty)= NaN</tex>

* <tex>0\times\infty= NaN</tex>

* <tex>\frac{\pm0}{\pm0}=\frac{\pm\infty}{\pm\infty} = NaN</tex>

* <tex>\sqrt{x} = NaN</tex>, где <tex>x<0</tex>

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

По определению NaN ≠ NaN, поэтому, для проверки значения переменной нужно просто сравнить ее с собой.


=== Бесконечности ===
В число с плавающей запятой можно записать значение <tex>+\infty</tex> или <tex>-\infty</tex>. Как и нули со знаком, бесконечности позволяют получить хотя бы близкий к правильному результат вычисления в случае переполнения. Согласно стандарту IEEE 754 число с плавающей запятой считается равным бесконечности, если все двоичные разряды его порядка {{---}} единицы, а мантисса равна нулю. Знак бесконечности определяется знаковым битом числа.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm\infty</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Получить бесконечность можно при переполнении и при делении ненулевого числа на ноль. При этом
<tex dpi = "180">
\frac{x}{0}
</tex>
<tex>=
\begin{cases}
+\infty,&\text{если $x>0$;}\\
NaN,&\text{если $x=0$;}\\
-\infty,&\text{если $x<0$.}
\end{cases}

</tex>

=== Денормализованные числа ===
'''Денормализованные числа''' (англ. ''denormalized/subnormal numbers'') - это способ увеличить количество представимых числом с плавающей запятой значений около нуля, дабы повысить точность вычислений. Каждое значение денормализованного числа меньше самого маленького '''нормализованного''' ("обычного") значения числа с плавающей запятой.
Согласно стандарту, если порядок равен своему минимальному значению (все его биты {{---}} нули, а истинное значение порядка равно его сдвигу) и все биты мантиссы равны нулю, то это <tex>\pm0</tex>. Если же мантисса не равна нулю, то это число с порядком, на единицу большим минимального (все биты порядка, кроме младшего {{---}} нули) и данной мантиссой, '''целая часть которой считается равной нулю, а не единице'''.

То есть число с плавающей запятой, при учете вышесказанного, можно задать следующим образом:
 
* <tex>(-1)^s\times1,M\times2^E</tex>, если <tex>E_{min} \le E \le E_{max}</tex> (''нормализованное число'')

* <tex>(-1)^s\times0,M\times2^{E_{min}}</tex>, если <tex>E=E_{min}-1</tex> (''денормализованное число'')

Где <tex>s</tex> {{---}} бит знака, <tex>M</tex> {{---}} последовательность битов мантиссы, <tex>E</tex> {{---}} значение порядка (с учетом сдвига), <tex>E_{min}</tex> {{---}} минимальное значение порядка, используемое для записи чисел (1 {{---}} ''сдвиг'') , <tex>E_{min}-1</tex> {{---}} минимальное значение порядка, которое он в принципе может принять (все биты нули, 0 {{---}} ''сдвиг'').

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

В современных процессорах обработка денормализованных чисел происходит в десятки раз медленнее, чем обработка нормализованных чисел. Ниже приведена часть таблицы из статьи Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values"<ref>[http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf Статья Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values" ''(англ.)'']</ref>

{| class="wikitable"
!Производитель||Процессор||Замедление (разы)
|-
|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-х разрядном формате <tex>-269</tex> <tex>7</tex><tex>/</tex><tex>32</tex> и <tex>405,875</tex>.
Переведем <tex>-269</tex> <tex>7</tex><tex>/</tex><tex>32</tex> в машинный вид. Для этого сначала переведем его в двоичную систему счисления.
<tex>-269</tex> <tex>7</tex><tex>/</tex><tex>32</tex> <tex>=</tex> <tex>-269{,}21875</tex>
<tex>-269{,}21875</tex><tex>10</tex> <tex>=</tex> <tex>-100001101{,}00111</tex><tex>2</tex>

Нормализуем полученное двоичное число по правилам машинной арифметики.
<tex>-100001101{,}00111</tex> <tex>=</tex> <tex>-1{,}0000110100111</tex><tex> \times</tex> <tex>10</tex><tex>1000</tex>

Найдем смещенный порядок. Так как в условии говорится о 32-разрядном представлении, то смещение порядка равно <tex>127</tex><tex>10</tex>.
<tex>E</tex> <tex>=</tex> <tex>8</tex><tex>10</tex> <tex>+</tex> <tex>127</tex><tex>10</tex> <tex>=</tex> <tex>1000</tex><tex>2</tex> <tex>+</tex> <tex>1111111</tex><tex>2</tex> <tex>=</tex> <tex>10000111</tex><tex>2</tex>

Число отрицательное, следовательно, в бите знака будет стоять единица.

Итак, первое число в машинном 32-разрядном представлении с плавающей точкой будет иметь вид:
<tex>1</tex>10000111<tex>00001101001110000000000</tex> (жирным шрифтом выделен порядок числа, длина мантиссы {{---}} 23 бита).

Переведем второе число в машинный вид, совершая те же действия.

<tex>405,87510</tex> = <tex>110010101</tex>,<tex>111000000000011010</tex>...<tex>2</tex> <tex>=</tex> <tex>1,10010101111000000000011010</tex>... <tex>\times</tex> <tex>10</tex><tex>1000</tex>
В качестве мантиссы будут сохранены первые <tex>23</tex> бита после запятой т.е. <tex>10010101111000000000011</tex>.
Очевидно, что порядок со смещением у второго числа будет таким же, как и у первого.

Второе число положительное, следовательно, бит знака будет содержать ноль.

Итак в машинном 32-разрядном представлении второе число будет иметь вид:

<tex>0</tex>10000111<tex>10010101111000000000011</tex>
Далее в арифметических операциях будет использоваться число <tex>110010101</tex>,<tex>111</tex><tex>2</tex>=<tex>405{,}875</tex><tex>10</tex>, а не <tex>110010101{,}111000000000011</tex><tex>2</tex>=<tex>405{,}87510</tex><tex>10</tex> видимо для упрощения(хотя это не совсем корректно).

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

<tex>1</tex>,<tex>1001010111100</tex><tex>2</tex> <tex>-</tex> <tex>1{,}0000110100111</tex><tex>2</tex> <tex>=</tex> <tex>0{,}1000100010101</tex><tex>2</tex>

Приводим полученный результат к машинному виду. Для этого мы должны внести поправку в порядок {{---}} уменьшить его на единицу.
Знак результата {{---}} положительный, следовательно, бит знака содержит ноль.

<tex>0</tex>10000110<tex>00010001010100000000000</tex>

Проверим правильность наших вычислений. Переведем результат в десятичное представление.

Найдем реальный порядок результата, вычтя из него значение смещения <tex>127</tex><tex>10</tex>.

<tex>E</tex> <tex>=</tex> <tex>10000110</tex><tex>2</tex> <tex>-</tex> <tex>1111111</tex><tex>2</tex> <tex>=</tex> <tex>134</tex><tex>10</tex> <tex>-</tex> <tex>127</tex><tex>10</tex> <tex>=</tex> <tex>7</tex><tex>10</tex> <tex>=</tex> <tex>111</tex><tex>2</tex>

Следовательно, число результата будет иметь вид:
<tex>A</tex> <tex>=</tex> <tex>1{,}000100010101</tex> <tex>\times</tex> <tex>10</tex><tex>111</tex> <tex>=</tex> <tex>10001000</tex>,<tex>10101</tex><tex>2</tex> <tex>=</tex> <tex>136{,}65625</tex><tex>10</tex>

Результат наших вычислений верен, так как <tex>405{,}875</tex> - <tex>269{,}21875</tex> <tex>=</tex> <tex>136{,}65625</tex>.

=== Алгоритм получения представления вещественного числа в памяти ЭВМ ===

Покажем преобразование действительного числа для представления его в

памяти ЭВМ на примере величины типа Double.

Как видно из таблицы, величина этого типа занимает в памяти <tex>8</tex> байт. На

рисунке ниже показано, как здесь представлены поля мантиссы и порядка (нумерация битов осуществляется справа налево):

{|class="wikitable"
!Знак || Смещённый порядок || Мантисса
|-
|63 || 62..52 || 51..0
|}

Можно заметить, что старший бит, отведенный под мантиссу, имеет номер

<tex>51</tex>, т.е. мантисса занимает младшие <tex>52</tex> бита. Черта указывает здесь на

положение двоичной запятой. Перед запятой должен стоять бит целой части

мантиссы, но поскольку она всегда равна <tex>1</tex>, здесь данный бит не требуется и

соответствующий разряд отсутствует в памяти (но он подразумевается).

Значение порядка хранится здесь не как целое число, представленное в

дополнительном коде. Для упрощения вычислений и сравнения действительных

чисел значение порядка в ЭВМ хранится в виде смещенного числа, т.е. к

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

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

соответствовал нуль. Например, для типа Double порядок занимает <tex>11</tex> бит и

имеет диапазон от <tex>2</tex><tex>-1023</tex> до <tex>2</tex><tex>1023</tex>, поэтому смещение равно <tex>1023</tex>(<tex>10</tex>) <tex>=</tex>

<tex>1111111111</tex>(<tex>2</tex>). Наконец, бит с номером <tex>63</tex> указывает на знак числа.

Таким образом, из вышесказанного вытекает следующий алгоритм для

получения представления действительного числа в памяти ЭВМ:

<OL>

<LI>перевести модуль данного числа в двоичную систему счисления;</LI>

<LI>нормализовать двоичное число, т.е. записать в виде M <tex> \times </tex>2p, где M 

мантисса (ее целая часть равна <tex>1</tex>(<tex>2</tex>)) и p  порядок, записанный в

десятичной системе счисления;</LI>

<LI>прибавить к порядку смещение и перевести смещенный порядок в двоичную

систему счисления;</LI>

<LI>учитывая знак заданного числа (0  положительное; 1  отрицательное),

выписать его представление в памяти ЭВМ.</LI>

</OL>

Пример. Запишем код числа <tex>-312</tex>,<tex>3125</tex>.

<OL>

<LI>Двоичная запись модуля этого числа имеет вид <tex>100111000{,}0101</tex>.</LI>

<LI>Имеем <tex>100111000{,}0101</tex> <tex>=</tex>

<tex>1{,}001110000101</tex><tex>\times</tex><tex>2</tex><tex>8</tex>.</LI>

<LI>Получаем смещенный порядок <tex>8</tex> <tex>+</tex> <tex>1023</tex> <tex>=</tex> <tex>1031</tex>. Далее имеем

<tex>1031</tex>(<tex>10</tex>) <tex>=</tex> <tex>10000000111</tex>(<tex>2</tex>).</LI>

<LI>Окончательно

{|class="wikitable"
| 1 || 10000000111 || 0011100001010000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

</LI>

</OL>

Очевидно, что более компактно полученный код стоит записать следующим

образом: C073850000000000(16).

Другой пример иллюстрирует обратный переход от кода действительного

числа к самому числу.

Пример. Пусть дан код 3FEC600000000000(16) или

<OL>

{|class="wikitable"
| 0 || 01111111110 || 1100011000000000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

<LI>Прежде всего замечаем, что это код положительного числа, поскольку в

разряде с номером <tex>63</tex> записан нуль. Получим порядок этого числа:

<tex>01111111110</tex>(<tex>2</tex>) <tex>=</tex> <tex>1022</tex>(<tex>10</tex>); <tex>1022</tex> <tex>-</tex> <tex>1023</tex> <tex>=</tex> <tex>-1</tex>.</LI>

<LI>Число имеет вид <tex>1</tex>,<tex>1100011</tex><tex> \times </tex><tex>2</tex><tex>-1</tex> или

<tex>0</tex>,<tex>11100011</tex>.</LI>

<LI>Переводом в десятичную систему счисления получаем <tex>0</tex>,<tex>88671875</tex>.</LI>

</OL>

== См. также ==
* [[Представление символов, таблицы кодировок]]
* [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]

== Примечания ==
<references/>

== Ссылки ==
=== Использованные материалы ===
'''На русском'''
* [http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C Википедия {{---}} Экспоненциальная запись]
* [http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D0%B7%D0%B0%D0%BF%D1%8F%D1%82%D0%BE%D0%B9 Википедия {{---}} Число с плавающей запятой]
* [http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%80%D0%B8%D1%86%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BD%D0%BE%D0%BB%D1%8C Википедия {{---}} Отрицательный и положительный ноль]
*[http://habrahabr.ru/blogs/cpp/112953/ Хабрахабр {{---}} статья пользователя Yruslan "Что нужно знать про арифметику с плавающей запятой"]
*[http://www.sgu.ru/prcnit/teach/3.php Статья Лапшевой Е.Е. "Машинная арифметика с вещественными числами"]

'''На английском'''
*[http://en.wikipedia.org/wiki/NaN Wikipedia {{---}} NaN]
*[http://en.wikipedia.org/wiki/Floating_point Wikipedia {{---}} Floating point]
*[http://en.wikipedia.org/wiki/IEEE_754-2008 Wikipedia {{---}} IEEE 754-2008]

=== Что стоит прочесть ===
* [http://grouper.ieee.org/groups/754 Материалы по стандарту IEEE 754 ''(англ.)'']
* [http://softelectro.ru/ieee754.html Русский перевод стандарта IEEE 754]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Представление информации]]

Представление вещественных чисел

2015-01-12T19:20:31Z

Паршуков Кирилл:

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

Число с плавающей запятой состоит из набора отдельных двоичных разрядов, условно разделенных на так называемые '''знак''' (англ.'' sign''), '''порядок''' (англ. ''exponent'') и '''мантиссу''' (англ. ''mantis''). В наиболее распространённом формате (стандарт IEEE 754) число с плавающей запятой представляется в виде набора битов, часть из которых кодирует собой мантиссу числа, другая часть — показатель степени, и ещё один бит используется для указания знака числа (<tex>0</tex> {{---}} если число положительное, <tex>1</tex> {{---}} если число отрицательное). При этом порядок записывается как целое число в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|коде со сдвигом]], а мантисса {{---}} в [[#Нормальная и нормализованная форма|нормализованном виде]], своей дробной частью в двоичной системе счисления. Вот пример такого числа из <tex>16</tex> двоичных разрядов:
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=10 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0

!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Знак {{---}} один бит, указывающий знак всего числа с плавающей точкой. Порядок и мантисса — целые числа, которые вместе со знаком дают представление числа с плавающей запятой в следующем виде:

<tex>(-1)^S \times M \times B^E</tex>, где <tex>S</tex> {{---}} знак, <tex>B</tex> {{---}} основание, <tex>E</tex> {{---}} порядок, а <tex>M</tex> {{---}} мантисса.
Десятичное число, записываемое как <tex> ReE</tex>, где <tex>R</tex> {{---}} число в полуинтервале <tex>[1; 10)</tex>, <tex>E</tex> {{---}} степень, в которой стоит множитель <tex>10</tex>; в нормализированной форме модуль <tex>R</tex> будет являться мантиссой, а <tex>E</tex> {{---}} порядком, а <tex>S</tex> будет равно <tex>1</tex> тогда и только тогда, когда <tex>R</tex> принимает отрицательное значение.
Например, в числе <tex>-2435e9</tex>
* <tex>S</tex> <tex>=</tex> <tex>1</tex>
* <tex>B</tex> <tex>=</tex> <tex>10</tex>
* <tex>M</tex> <tex>=</tex> <tex>2435</tex>
* <tex>E</tex> <tex>=</tex> <tex>9</tex>

Порядок также иногда называют '''экспонентой''' или просто '''показателем степени'''.


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

Более простым вариантом представления вещественных чисел является вариант с фиксированной точкой, когда целая и вещественная части хранятся отдельно. Например, на целую часть отводится всегда <tex>X</tex> бит и на дробную отводится всегда <tex>Y</tex> бит. Такой способ в архитектурах процессоров не присутствует. Отдаётся предпочтение числам с плавающей запятой, как компромиссу между диапазоном допустимых значений и точностью.

== Нормальная и нормализованная форма ==

'''Нормальной формой''' (англ. ''normal form'') числа с плавающей запятой называется такая форма, в которой мантисса (без учёта знака) в десятичной системе находится на полуинтервале <tex>[0; 1)</tex>. Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, <tex>0{,}0001</tex> можно записать в 4 формах — <tex>0{,}0001</tex> \times <tex>10</tex><tex>0</tex>, <tex>0{,}001</tex> \times <tex>10</tex><tex>−1</tex>, <tex>0{,}01</tex> \times <tex>10</tex><tex>−2</tex>, <tex>0{,}1</tex> \times <tex>10</tex><tex>−3</tex>), поэтому распространена также другая форма записи — '''нормализованная''' (англ. ''normalized''), в которой мантисса десятичного числа принимает значения от <tex>1</tex> (включительно) до <tex>10</tex> (не включительно), а мантисса двоичного числа принимает значения от <tex>1</tex> (включительно) до <tex>2</tex> (не включительно). То есть в мантиссе слева от запятой до применения порядка находится ровно один знак. В такой форме любое число (кроме <tex>0</tex>) записывается единственным образом. Ноль же представить таким образом невозможно, поэтому стандарт предусматривает специальную последовательность битов для задания числа <tex>0</tex> (а заодно и некоторых других [[#Особые значения чисел с плавающей точкой|полезных чисел]], таких как <tex>-\infty</tex> и <tex>+\infty</tex>).
Так как старший двоичный разряд (целая часть) мантиссы вещественного числа в нормализованном виде всегда равен «<tex>1</tex>», то его можно не записывать, сэкономив таким образом один бит, что и используется в стандарте IEEE 754. В позиционных системах счисления с основанием большим, чем <tex>2</tex> (в троичной, четверичной и др.), этого замечательного свойства нет (ведь целая часть там может быть не только единицей).

== Типы чисел с плавающей точкой (по IEEE 754) ==
=== Число половинной точности (''Binary16'', ''Half precision'') ===

'''Число́ полови́нной то́чности''' — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — <tex>16</tex> бит или <tex>2</tex> байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=3 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=2 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=6 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|со сдвигом]] '''<tex>-15</tex>'''. То есть чтобы получить актуально значение порядка нужно вычесть из него сдвиг. Сдвиг можно получить по формуле <tex>2^{b-1}-1</tex>, где <tex>b</tex> {{---}} число бит, отведенное на хранение порядка (в случае числа половинной точности <tex>b=5</tex>).

'''Ограничения точности'''
* Целые от нуля до <tex>2048</tex> передаются как есть.
* Целые от <tex>2049</tex> до <tex>4096</tex> округляются к ближайшему чётному целому.
* Целые от <tex>4097</tex> до <tex>8192</tex> округляются до ближайшего целого, делящегося нацело на четыре.
* Целые от <tex>8193</tex> до <tex>16384</tex> округляются до ближайшего целого, делящегося на восемь.
* Целые от <tex>16385</tex> до <tex>32768</tex> округляются до ближайшего целого, делящегося на шестнадцать.
* Целые от <tex>32769</tex> до <tex>65535</tex> округляются до ближайшего целого, делящегося на тридцать два.

=== Число одинарной точности (''Binary32'', ''Single precision'', ''float'') ===

'''Число́ одина́рной то́чности''' — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — <tex>32</tex> бита или <tex>4</tex> байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.

{|class="wikitable" style="background-color: transparent; border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=8 style="background-color: lightgreen; border: thin solid black"|Порядок (8 бит)
!colspan=24 style="background-color: lightcoral; border: thin solid black"|Мантисса (23+1 бита)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"|
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|30
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|23
|style="border: none"|
|colspan=20 style="border: none; border-left: 1px solid gray; text-align: left"|22
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-127</tex>'''.

=== Число двойной точности (''Binary64'', ''Double precision'', ''double'') ===

'''Число́ двойно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — <tex>64</tex> бита или <tex>8</tex> байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=11 style="background-color: lightgreen; border: thin solid black"|Порядок (11 бит)
!colspan=53 style="background-color: lightcoral; border: thin solid black"|Мантисса (52+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|62
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|52
|style="border: none"|
|colspan=48 style="border: none; border-left: 1px solid gray; text-align: left"|51
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-1023</tex>'''.

=== Число четверной точности (''Binary128'', ''Quadruple precision'') ===

'''Число́ четверно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — <tex>128</tex> бит или <tex>16</tex> байт). Используется в случае необходимости крайне высокой точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=15 style="background-color: lightgreen; border: thin solid black"|Порядок (15 бит)
!colspan=47 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=8 style="border: none; border-left: 1px solid gray; text-align: left"|126
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|112
|style="border: none"|
|colspan=38 style="border: none; border-left: 1px solid gray; text-align: left"|111
|}
 
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=66 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|colspan=66 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-16383</tex>'''.

Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки. Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью).
В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.

=== Диапазон значений чисел с плавающей запятой ===
Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, "не число", получается как результат операций типа деления нуля на ноль) и <tex>\pm\infty</tex>.

Данная таблица только лишь примерно указывает границы допустимых значений, без учета возрастающей погрешности с ростом абсолютного значения и существования [[#Денормализованные числа|денормализованных чисел]].


{| class="wikitable"
!Название в IEEE 754|| Название типа переменной в Си || Диапазон значений || Бит в мантиссе || Бит на переменную
|-
|Half precision||-||6,10×10-5..65504||11||16
|-
|Single presicion||float||3,4×10-38..3,4×1038||23||32
|-
|Double precision||double||1,7×10-308..1,7×10308||53||64
|-
|Extended precision||На некоторых архитектурах (например в сопроцессоре Intel) long double||3,4×10-4932..3,4×104932||65||80
|}

== Особые значения чисел с плавающей точкой ==
=== Ноль (со знаком) ===
Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль. Поэтому для его представления зарезервированы специальные значения мантиссы и порядка {{---}} число считается нулём, если все его биты, кроме знакового, равны нулю. При этом в зависимости от значения бита знака ноль может быть как положительным, так и отрицательным.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm0</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

'''Арифметика нуля со знаком'''
 
Арифметика отрицательного нуля аналогична таковой для любого отрицательного числа и понятна интуитивно. Вот несколько примеров:

* <tex>\frac{-0}{ \left| x \right| } = -0\,\!</tex> (если <tex>x\ne0</tex>)

* <tex>(-0) \cdot (-0) = +0\,\!</tex>

* <tex>\left| x \right| \cdot (-0) = -0\,\!</tex>

* <tex>x + (\pm 0) = x\,\!</tex>

* <tex>(-0) + (-0) = -0\,\!</tex>

* <tex>(+0) + (+0) = +0\,\!</tex>

* <tex>\frac{-0}{-\infty} = +0\,\!</tex>

* <tex>\frac{\left|x\right|}{-0} = -\infty\,\!</tex> (если <tex>x\ne0</tex>)

=== Неопределенность (''NaN'') ===
'''NaN''' {{---}} это аббревиатура от фразы "''not a number''". NaN является результатом арифметических операций, если во время их выполнения произошла ошибка (примеры см. ниже). В IEEE 754 NaN представлен как число, в котором все двоичные разряды порядка {{---}} единицы, а мантисса не нулевая.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: transparent; border: none"| = <tex>NaN</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.

'''Как можно получить NaN?'''
 

* <tex>\infty+(-\infty)= NaN</tex>

* <tex>0\times\infty= NaN</tex>

* <tex>\frac{\pm0}{\pm0}=\frac{\pm\infty}{\pm\infty} = NaN</tex>

* <tex>\sqrt{x} = NaN</tex>, где <tex>x<0</tex>

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

По определению NaN ≠ NaN, поэтому, для проверки значения переменной нужно просто сравнить ее с собой.


=== Бесконечности ===
В число с плавающей запятой можно записать значение <tex>+\infty</tex> или <tex>-\infty</tex>. Как и нули со знаком, бесконечности позволяют получить хотя бы близкий к правильному результат вычисления в случае переполнения. Согласно стандарту IEEE 754 число с плавающей запятой считается равным бесконечности, если все двоичные разряды его порядка {{---}} единицы, а мантисса равна нулю. Знак бесконечности определяется знаковым битом числа.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm\infty</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Получить бесконечность можно при переполнении и при делении ненулевого числа на ноль. При этом
<tex dpi = "180">
\frac{x}{0}
</tex>
<tex>=
\begin{cases}
+\infty,&\text{если $x>0$;}\\
NaN,&\text{если $x=0$;}\\
-\infty,&\text{если $x<0$.}
\end{cases}

</tex>

=== Денормализованные числа ===
'''Денормализованные числа''' (англ. ''denormalized/subnormal numbers'') - это способ увеличить количество представимых числом с плавающей запятой значений около нуля, дабы повысить точность вычислений. Каждое значение денормализованного числа меньше самого маленького '''нормализованного''' ("обычного") значения числа с плавающей запятой.
Согласно стандарту, если порядок равен своему минимальному значению (все его биты {{---}} нули, а истинное значение порядка равно его сдвигу) и все биты мантиссы равны нулю, то это <tex>\pm0</tex>. Если же мантисса не равна нулю, то это число с порядком, на единицу большим минимального (все биты порядка, кроме младшего {{---}} нули) и данной мантиссой, '''целая часть которой считается равной нулю, а не единице'''.

То есть число с плавающей запятой, при учете вышесказанного, можно задать следующим образом:
 
* <tex>(-1)^s\times1,M\times2^E</tex>, если <tex>E_{min} \le E \le E_{max}</tex> (''нормализованное число'')

* <tex>(-1)^s\times0,M\times2^{E_{min}}</tex>, если <tex>E=E_{min}-1</tex> (''денормализованное число'')

Где <tex>s</tex> {{---}} бит знака, <tex>M</tex> {{---}} последовательность битов мантиссы, <tex>E</tex> {{---}} значение порядка (с учетом сдвига), <tex>E_{min}</tex> {{---}} минимальное значение порядка, используемое для записи чисел (1 {{---}} ''сдвиг'') , <tex>E_{min}-1</tex> {{---}} минимальное значение порядка, которое он в принципе может принять (все биты нули, 0 {{---}} ''сдвиг'').

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

В современных процессорах обработка денормализованных чисел происходит в десятки раз медленнее, чем обработка нормализованных чисел. Ниже приведена часть таблицы из статьи Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values"<ref>[http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf Статья Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values" ''(англ.)'']</ref>

{| class="wikitable"
!Производитель||Процессор||Замедление (разы)
|-
|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-х разрядном формате <tex>-269</tex> <tex>7</tex><tex>/</tex><tex>32</tex> и <tex>405,875</tex>.
Переведем <tex>-269</tex> <tex>7</tex><tex>/</tex><tex>32</tex> в машинный вид. Для этого сначала переведем его в двоичную систему счисления.
<tex>-269</tex> <tex>7</tex><tex>/</tex><tex>32</tex> <tex>=</tex> <tex>-269{,}21875</tex>
<tex>-269{,}21875</tex><tex>10</tex> <tex>=</tex> <tex>-100001101{,}00111</tex><tex>2</tex>

Нормализуем полученное двоичное число по правилам машинной арифметики.
<tex>-100001101{,}00111</tex> <tex>=</tex> <tex>-1{,}0000110100111</tex><tex> \times</tex> <tex>10</tex><tex>1000</tex>

Найдем смещенный порядок. Так как в условии говорится о 32-разрядном представлении, то смещение порядка равно <tex>127</tex><tex>10</tex>.
<tex>E</tex> <tex>=</tex> <tex>8</tex><tex>10</tex> <tex>+</tex> <tex>127</tex><tex>10</tex> <tex>=</tex> <tex>1000</tex><tex>2</tex> <tex>+</tex> <tex>1111111</tex><tex>2</tex> <tex>=</tex> <tex>10000111</tex><tex>2</tex>

Число отрицательное, следовательно, в бите знака будет стоять единица.

Итак, первое число в машинном 32-разрядном представлении с плавающей точкой будет иметь вид:
<tex>1</tex>10000111<tex>00001101001110000000000</tex> (жирным шрифтом выделен порядок числа, длина мантиссы {{---}} 23 бита).

Переведем второе число в машинный вид, совершая те же действия.

<tex>405,87510</tex> = <tex>110010101</tex>,<tex>111000000000011010</tex>...<tex>2</tex> <tex>=</tex> <tex>1,10010101111000000000011010</tex>... × <tex>10</tex><tex>1000</tex>
В качестве мантиссы будут сохранены первые <tex>23</tex> бита после запятой т.е. <tex>10010101111000000000011</tex>.
Очевидно, что порядок со смещением у второго числа будет таким же, как и у первого.

Второе число положительное, следовательно, бит знака будет содержать ноль.

Итак в машинном 32-разрядном представлении второе число будет иметь вид:

<tex>0</tex>10000111<tex>10010101111000000000011</tex>
Далее в арифметических операциях будет использоваться число <tex>110010101</tex>,<tex>111</tex><tex>2</tex>=<tex>405{,}875</tex><tex>10</tex>, а не <tex>110010101{,}111000000000011</tex><tex>2</tex>=<tex>405{,}87510</tex><tex>10</tex> видимо для упрощения(хотя это не совсем корректно).

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

<tex>1</tex>,<tex>1001010111100</tex><tex>2</tex> <tex>-</tex> <tex>1{,}0000110100111</tex><tex>2</tex> <tex>=</tex> <tex>0{,}1000100010101</tex><tex>2</tex>

Приводим полученный результат к машинному виду. Для этого мы должны внести поправку в порядок {{---}} уменьшить его на единицу.
Знак результата {{---}} положительный, следовательно, бит знака содержит ноль.

<tex>0</tex>10000110<tex>00010001010100000000000</tex>

Проверим правильность наших вычислений. Переведем результат в десятичное представление.

Найдем реальный порядок результата, вычтя из него значение смещения <tex>127</tex><tex>10</tex>.

<tex>E</tex> <tex>=</tex> <tex>10000110</tex><tex>2</tex> <tex>-</tex> <tex>1111111</tex><tex>2</tex> <tex>=</tex> <tex>134</tex><tex>10</tex> <tex>-</tex> <tex>127</tex><tex>10</tex> <tex>=</tex> <tex>7</tex><tex>10</tex> <tex>=</tex> <tex>111</tex><tex>2</tex>

Следовательно, число результата будет иметь вид:
<tex>A</tex> <tex>=</tex> <tex>1{,}000100010101</tex> <tex>\times</tex> <tex>10</tex><tex>111</tex> <tex>=</tex> <tex>10001000</tex>,<tex>10101</tex><tex>2</tex> <tex>=</tex> <tex>136{,}65625</tex><tex>10</tex>

Результат наших вычислений верен, так как <tex>405{,}875</tex> - <tex>269{,}21875</tex> <tex>=</tex> <tex>136{,}65625</tex>.

=== Алгоритм получения представления вещественного числа в памяти ЭВМ ===

Покажем преобразование действительного числа для представления его в

памяти ЭВМ на примере величины типа Double.

Как видно из таблицы, величина этого типа занимает в памяти <tex>8</tex> байт. На

рисунке ниже показано, как здесь представлены поля мантиссы и порядка (нумерация битов осуществляется справа налево):

{|class="wikitable"
!Знак || Смещённый порядок || Мантисса
|-
|63 || 62..52 || 51..0
|}

Можно заметить, что старший бит, отведенный под мантиссу, имеет номер

<tex>51</tex>, т.е. мантисса занимает младшие <tex>52</tex> бита. Черта указывает здесь на

положение двоичной запятой. Перед запятой должен стоять бит целой части

мантиссы, но поскольку она всегда равна <tex>1</tex>, здесь данный бит не требуется и

соответствующий разряд отсутствует в памяти (но он подразумевается).

Значение порядка хранится здесь не как целое число, представленное в

дополнительном коде. Для упрощения вычислений и сравнения действительных

чисел значение порядка в ЭВМ хранится в виде смещенного числа, т.е. к

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

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

соответствовал нуль. Например, для типа Double порядок занимает <tex>11</tex> бит и

имеет диапазон от <tex>2</tex><tex>-1023</tex> до <tex>2</tex><tex>1023</tex>, поэтому смещение равно <tex>1023</tex>(<tex>10</tex>) <tex>=</tex>

<tex>1111111111</tex>(<tex>2</tex>). Наконец, бит с номером <tex>63</tex> указывает на знак числа.

Таким образом, из вышесказанного вытекает следующий алгоритм для

получения представления действительного числа в памяти ЭВМ:

<OL>

<LI>перевести модуль данного числа в двоичную систему счисления;</LI>

<LI>нормализовать двоичное число, т.е. записать в виде M × 2p, где M 

мантисса (ее целая часть равна <tex>1</tex>(<tex>2</tex>)) и p  порядок, записанный в

десятичной системе счисления;</LI>

<LI>прибавить к порядку смещение и перевести смещенный порядок в двоичную

систему счисления;</LI>

<LI>учитывая знак заданного числа (0  положительное; 1  отрицательное),

выписать его представление в памяти ЭВМ.</LI>

</OL>

Пример. Запишем код числа <tex>-312</tex>,<tex>3125</tex>.

<OL>

<LI>Двоичная запись модуля этого числа имеет вид <tex>100111000{,}0101</tex>.</LI>

<LI>Имеем <tex>100111000{,}0101</tex> <tex>=</tex>

<tex>1{,}001110000101</tex><tex>\times</tex><tex>2</tex><tex>8</tex>.</LI>

<LI>Получаем смещенный порядок <tex>8</tex> <tex>+</tex> <tex>1023</tex> <tex>=</tex> <tex>1031</tex>. Далее имеем

<tex>1031</tex>(<tex>10</tex>) <tex>=</tex> <tex>10000000111</tex>(<tex>2</tex>).</LI>

<LI>Окончательно

{|class="wikitable"
| 1 || 10000000111 || 0011100001010000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

</LI>

</OL>

Очевидно, что более компактно полученный код стоит записать следующим

образом: C073850000000000(16).

Другой пример иллюстрирует обратный переход от кода действительного

числа к самому числу.

Пример. Пусть дан код 3FEC600000000000(16) или

<OL>

{|class="wikitable"
| 0 || 01111111110 || 1100011000000000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

<LI>Прежде всего замечаем, что это код положительного числа, поскольку в

разряде с номером <tex>63</tex> записан нуль. Получим порядок этого числа:

<tex>01111111110</tex>(<tex>2</tex>) <tex>=</tex> <tex>1022</tex>(<tex>10</tex>); <tex>1022</tex> <tex>-</tex> <tex>1023</tex> <tex>=</tex> <tex>-1</tex>.</LI>

<LI>Число имеет вид <tex>1</tex>,<tex>1100011</tex> × <tex>2</tex><tex>-1</tex> или

<tex>0</tex>,<tex>11100011</tex>.</LI>

<LI>Переводом в десятичную систему счисления получаем <tex>0</tex>,<tex>88671875</tex>.</LI>

</OL>

== См. также ==
* [[Представление символов, таблицы кодировок]]
* [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]

== Примечания ==
<references/>

== Ссылки ==
=== Использованные материалы ===
'''На русском'''
* [http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C Википедия {{---}} Экспоненциальная запись]
* [http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D0%B7%D0%B0%D0%BF%D1%8F%D1%82%D0%BE%D0%B9 Википедия {{---}} Число с плавающей запятой]
* [http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%80%D0%B8%D1%86%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BD%D0%BE%D0%BB%D1%8C Википедия {{---}} Отрицательный и положительный ноль]
*[http://habrahabr.ru/blogs/cpp/112953/ Хабрахабр {{---}} статья пользователя Yruslan "Что нужно знать про арифметику с плавающей запятой"]
*[http://www.sgu.ru/prcnit/teach/3.php Статья Лапшевой Е.Е. "Машинная арифметика с вещественными числами"]

'''На английском'''
*[http://en.wikipedia.org/wiki/NaN Wikipedia {{---}} NaN]
*[http://en.wikipedia.org/wiki/Floating_point Wikipedia {{---}} Floating point]
*[http://en.wikipedia.org/wiki/IEEE_754-2008 Wikipedia {{---}} IEEE 754-2008]

=== Что стоит прочесть ===
* [http://grouper.ieee.org/groups/754 Материалы по стандарту IEEE 754 ''(англ.)'']
* [http://softelectro.ru/ieee754.html Русский перевод стандарта IEEE 754]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Представление информации]]

Представление вещественных чисел

2015-01-12T19:16:45Z

Паршуков Кирилл:

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

Число с плавающей запятой состоит из набора отдельных двоичных разрядов, условно разделенных на так называемые '''знак''' (англ.'' sign''), '''порядок''' (англ. ''exponent'') и '''мантиссу''' (англ. ''mantis''). В наиболее распространённом формате (стандарт IEEE 754) число с плавающей запятой представляется в виде набора битов, часть из которых кодирует собой мантиссу числа, другая часть — показатель степени, и ещё один бит используется для указания знака числа (<tex>0</tex> {{---}} если число положительное, <tex>1</tex> {{---}} если число отрицательное). При этом порядок записывается как целое число в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|коде со сдвигом]], а мантисса {{---}} в [[#Нормальная и нормализованная форма|нормализованном виде]], своей дробной частью в двоичной системе счисления. Вот пример такого числа из <tex>16</tex> двоичных разрядов:
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=10 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0

!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Знак {{---}} один бит, указывающий знак всего числа с плавающей точкой. Порядок и мантисса — целые числа, которые вместе со знаком дают представление числа с плавающей запятой в следующем виде:

<tex>(-1)^S \times M \times B^E</tex>, где <tex>S</tex> {{---}} знак, <tex>B</tex> {{---}} основание, <tex>E</tex> {{---}} порядок, а <tex>M</tex> {{---}} мантисса.
Десятичное число, записываемое как <tex> ReE</tex>, где <tex>R</tex> {{---}} число в полуинтервале <tex>[1; 10)</tex>, <tex>E</tex> {{---}} степень, в которой стоит множитель <tex>10</tex>; в нормализированной форме модуль <tex>R</tex> будет являться мантиссой, а <tex>E</tex> {{---}} порядком, а <tex>S</tex> будет равно <tex>1</tex> тогда и только тогда, когда <tex>R</tex> принимает отрицательное значение.
Например, в числе <tex>-2435e9</tex>
* <tex>S</tex> <tex>=</tex> <tex>1</tex>
* <tex>B</tex> <tex>=</tex> <tex>10</tex>
* <tex>M</tex> <tex>=</tex> <tex>2435</tex>
* <tex>E</tex> <tex>=</tex> <tex>9</tex>

Порядок также иногда называют '''экспонентой''' или просто '''показателем степени'''.


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

Более простым вариантом представления вещественных чисел является вариант с фиксированной точкой, когда целая и вещественная части хранятся отдельно. Например, на целую часть отводится всегда <tex>X</tex> бит и на дробную отводится всегда <tex>Y</tex> бит. Такой способ в архитектурах процессоров не присутствует. Отдаётся предпочтение числам с плавающей запятой, как компромиссу между диапазоном допустимых значений и точностью.

== Нормальная и нормализованная форма ==

'''Нормальной формой''' (англ. ''normal form'') числа с плавающей запятой называется такая форма, в которой мантисса (без учёта знака) в десятичной системе находится на полуинтервале <tex>[0; 1)</tex>. Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, <tex>0{,}0001</tex> можно записать в 4 формах — <tex>0{,}0001</tex> \times <tex>10</tex><tex>0</tex>, <tex>0{,}001</tex> \times <tex>10</tex><tex>−1</tex>, <tex>0{,}01</tex> \times <tex>10</tex><tex>−2</tex>, <tex>0{,}1</tex> \times <tex>10</tex><tex>−3</tex>), поэтому распространена также другая форма записи — '''нормализованная''' (англ. ''normalized''), в которой мантисса десятичного числа принимает значения от <tex>1</tex> (включительно) до <tex>10</tex> (не включительно), а мантисса двоичного числа принимает значения от <tex>1</tex> (включительно) до <tex>2</tex> (не включительно). То есть в мантиссе слева от запятой до применения порядка находится ровно один знак. В такой форме любое число (кроме <tex>0</tex>) записывается единственным образом. Ноль же представить таким образом невозможно, поэтому стандарт предусматривает специальную последовательность битов для задания числа <tex>0</tex> (а заодно и некоторых других [[#Особые значения чисел с плавающей точкой|полезных чисел]], таких как <tex>-\infty</tex> и <tex>+\infty</tex>).
Так как старший двоичный разряд (целая часть) мантиссы вещественного числа в нормализованном виде всегда равен «<tex>1</tex>», то его можно не записывать, сэкономив таким образом один бит, что и используется в стандарте IEEE 754. В позиционных системах счисления с основанием большим, чем <tex>2</tex> (в троичной, четверичной и др.), этого замечательного свойства нет (ведь целая часть там может быть не только единицей).

== Типы чисел с плавающей точкой (по IEEE 754) ==
=== Число половинной точности (''Binary16'', ''Half precision'') ===

'''Число́ полови́нной то́чности''' — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — <tex>16</tex> бит или <tex>2</tex> байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=3 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=2 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=6 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|со сдвигом]] '''<tex>-15</tex>'''. То есть чтобы получить актуально значение порядка нужно вычесть из него сдвиг. Сдвиг можно получить по формуле <tex>2^{b-1}-1</tex>, где <tex>b</tex> {{---}} число бит, отведенное на хранение порядка (в случае числа половинной точности <tex>b=5</tex>).

'''Ограничения точности'''
* Целые от нуля до <tex>2048</tex> передаются как есть.
* Целые от <tex>2049</tex> до <tex>4096</tex> округляются к ближайшему чётному целому.
* Целые от <tex>4097</tex> до <tex>8192</tex> округляются до ближайшего целого, делящегося нацело на четыре.
* Целые от <tex>8193</tex> до <tex>16384</tex> округляются до ближайшего целого, делящегося на восемь.
* Целые от <tex>16385</tex> до <tex>32768</tex> округляются до ближайшего целого, делящегося на шестнадцать.
* Целые от <tex>32769</tex> до <tex>65535</tex> округляются до ближайшего целого, делящегося на тридцать два.

=== Число одинарной точности (''Binary32'', ''Single precision'', ''float'') ===

'''Число́ одина́рной то́чности''' — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — <tex>32</tex> бита или <tex>4</tex> байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.

{|class="wikitable" style="background-color: transparent; border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=8 style="background-color: lightgreen; border: thin solid black"|Порядок (8 бит)
!colspan=24 style="background-color: lightcoral; border: thin solid black"|Мантисса (23+1 бита)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"|
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|30
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|23
|style="border: none"|
|colspan=20 style="border: none; border-left: 1px solid gray; text-align: left"|22
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-127</tex>'''.

=== Число двойной точности (''Binary64'', ''Double precision'', ''double'') ===

'''Число́ двойно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — <tex>64</tex> бита или <tex>8</tex> байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=11 style="background-color: lightgreen; border: thin solid black"|Порядок (11 бит)
!colspan=53 style="background-color: lightcoral; border: thin solid black"|Мантисса (52+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|62
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|52
|style="border: none"|
|colspan=48 style="border: none; border-left: 1px solid gray; text-align: left"|51
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-1023</tex>'''.

=== Число четверной точности (''Binary128'', ''Quadruple precision'') ===

'''Число́ четверно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — <tex>128</tex> бит или <tex>16</tex> байт). Используется в случае необходимости крайне высокой точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=15 style="background-color: lightgreen; border: thin solid black"|Порядок (15 бит)
!colspan=47 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=8 style="border: none; border-left: 1px solid gray; text-align: left"|126
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|112
|style="border: none"|
|colspan=38 style="border: none; border-left: 1px solid gray; text-align: left"|111
|}
 
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=66 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|colspan=66 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-16383</tex>'''.

Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки. Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью).
В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.

=== Диапазон значений чисел с плавающей запятой ===
Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, "не число", получается как результат операций типа деления нуля на ноль) и <tex>\pm\infty</tex>.

Данная таблица только лишь примерно указывает границы допустимых значений, без учета возрастающей погрешности с ростом абсолютного значения и существования [[#Денормализованные числа|денормализованных чисел]].


{| class="wikitable"
!Название в IEEE 754|| Название типа переменной в Си || Диапазон значений || Бит в мантиссе || Бит на переменную
|-
|Half precision||-||6,10×10-5..65504||11||16
|-
|Single presicion||float||3,4×10-38..3,4×1038||23||32
|-
|Double precision||double||1,7×10-308..1,7×10308||53||64
|-
|Extended precision||На некоторых архитектурах (например в сопроцессоре Intel) long double||3,4×10-4932..3,4×104932||65||80
|}

== Особые значения чисел с плавающей точкой ==
=== Ноль (со знаком) ===
Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль. Поэтому для его представления зарезервированы специальные значения мантиссы и порядка {{---}} число считается нулём, если все его биты, кроме знакового, равны нулю. При этом в зависимости от значения бита знака ноль может быть как положительным, так и отрицательным.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm0</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

'''Арифметика нуля со знаком'''
 
Арифметика отрицательного нуля аналогична таковой для любого отрицательного числа и понятна интуитивно. Вот несколько примеров:

* <tex>\frac{-0}{ \left| x \right| } = -0\,\!</tex> (если <tex>x\ne0</tex>)

* <tex>(-0) \cdot (-0) = +0\,\!</tex>

* <tex>\left| x \right| \cdot (-0) = -0\,\!</tex>

* <tex>x + (\pm 0) = x\,\!</tex>

* <tex>(-0) + (-0) = -0\,\!</tex>

* <tex>(+0) + (+0) = +0\,\!</tex>

* <tex>\frac{-0}{-\infty} = +0\,\!</tex>

* <tex>\frac{\left|x\right|}{-0} = -\infty\,\!</tex> (если <tex>x\ne0</tex>)

=== Неопределенность (''NaN'') ===
'''NaN''' {{---}} это аббревиатура от фразы "''not a number''". NaN является результатом арифметических операций, если во время их выполнения произошла ошибка (примеры см. ниже). В IEEE 754 NaN представлен как число, в котором все двоичные разряды порядка {{---}} единицы, а мантисса не нулевая.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: transparent; border: none"| = <tex>NaN</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.

'''Как можно получить NaN?'''
 

* <tex>\infty+(-\infty)= NaN</tex>

* <tex>0\times\infty= NaN</tex>

* <tex>\frac{\pm0}{\pm0}=\frac{\pm\infty}{\pm\infty} = NaN</tex>

* <tex>\sqrt{x} = NaN</tex>, где <tex>x<0</tex>

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

По определению NaN ≠ NaN, поэтому, для проверки значения переменной нужно просто сравнить ее с собой.


=== Бесконечности ===
В число с плавающей запятой можно записать значение <tex>+\infty</tex> или <tex>-\infty</tex>. Как и нули со знаком, бесконечности позволяют получить хотя бы близкий к правильному результат вычисления в случае переполнения. Согласно стандарту IEEE 754 число с плавающей запятой считается равным бесконечности, если все двоичные разряды его порядка {{---}} единицы, а мантисса равна нулю. Знак бесконечности определяется знаковым битом числа.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm\infty</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Получить бесконечность можно при переполнении и при делении ненулевого числа на ноль. При этом
<tex dpi = "180">
\frac{x}{0}
</tex>
<tex>=
\begin{cases}
+\infty,&\text{если $x>0$;}\\
NaN,&\text{если $x=0$;}\\
-\infty,&\text{если $x<0$.}
\end{cases}

</tex>

=== Денормализованные числа ===
'''Денормализованные числа''' (англ. ''denormalized/subnormal numbers'') - это способ увеличить количество представимых числом с плавающей запятой значений около нуля, дабы повысить точность вычислений. Каждое значение денормализованного числа меньше самого маленького '''нормализованного''' ("обычного") значения числа с плавающей запятой.
Согласно стандарту, если порядок равен своему минимальному значению (все его биты {{---}} нули, а истинное значение порядка равно его сдвигу) и все биты мантиссы равны нулю, то это <tex>\pm0</tex>. Если же мантисса не равна нулю, то это число с порядком, на единицу большим минимального (все биты порядка, кроме младшего {{---}} нули) и данной мантиссой, '''целая часть которой считается равной нулю, а не единице'''.

То есть число с плавающей запятой, при учете вышесказанного, можно задать следующим образом:
 
* <tex>(-1)^s\times1,M\times2^E</tex>, если <tex>E_{min} \le E \le E_{max}</tex> (''нормализованное число'')

* <tex>(-1)^s\times0,M\times2^{E_{min}}</tex>, если <tex>E=E_{min}-1</tex> (''денормализованное число'')

Где <tex>s</tex> {{---}} бит знака, <tex>M</tex> {{---}} последовательность битов мантиссы, <tex>E</tex> {{---}} значение порядка (с учетом сдвига), <tex>E_{min}</tex> {{---}} минимальное значение порядка, используемое для записи чисел (1 {{---}} ''сдвиг'') , <tex>E_{min}-1</tex> {{---}} минимальное значение порядка, которое он в принципе может принять (все биты нули, 0 {{---}} ''сдвиг'').

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

В современных процессорах обработка денормализованных чисел происходит в десятки раз медленнее, чем обработка нормализованных чисел. Ниже приведена часть таблицы из статьи Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values"<ref>[http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf Статья Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values" ''(англ.)'']</ref>

{| class="wikitable"
!Производитель||Процессор||Замедление (разы)
|-
|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-х разрядном формате <tex>-269</tex> <tex>7</tex><tex>/</tex><tex>32</tex> и <tex>405,875</tex>.
Переведем <tex>-269</tex> <tex>7</tex><tex>/</tex><tex>32</tex> в машинный вид. Для этого сначала переведем его в двоичную систему счисления.
<tex>-269</tex> <tex>7</tex><tex>/</tex><tex>32</tex> <tex>=</tex> <tex>-269{,}21875</tex>
<tex>-269{,}21875</tex><tex>10</tex> <tex>=</tex> <tex>-100001101{,}00111</tex><tex>2</tex>

Нормализуем полученное двоичное число по правилам машинной арифметики.
<tex>-100001101{,}00111</tex> <tex>=</tex> <tex>-1{,}0000110100111</tex><tex> ×</tex> <tex>10</tex><tex>1000</tex>

Найдем смещенный порядок. Так как в условии говорится о 32-разрядном представлении, то смещение порядка равно <tex>127</tex><tex>10</tex>.
<tex>E</tex> <tex>=</tex> <tex>8</tex><tex>10</tex> <tex>+</tex> <tex>127</tex><tex>10</tex> <tex>=</tex> <tex>1000</tex><tex>2</tex> <tex>+</tex> <tex>1111111</tex><tex>2</tex> <tex>=</tex> <tex>10000111</tex><tex>2</tex>

Число отрицательное, следовательно, в бите знака будет стоять единица.

Итак, первое число в машинном 32-разрядном представлении с плавающей точкой будет иметь вид:
<tex>1</tex>10000111<tex>00001101001110000000000</tex> (жирным шрифтом выделен порядок числа, длина мантиссы {{---}} 23 бита).

Переведем второе число в машинный вид, совершая те же действия.

<tex>405,87510</tex> = <tex>110010101</tex>,<tex>111000000000011010</tex>...<tex>2</tex> <tex>=</tex> <tex>1,10010101111000000000011010</tex>... × <tex>10</tex><tex>1000</tex>
В качестве мантиссы будут сохранены первые <tex>23</tex> бита после запятой т.е. <tex>10010101111000000000011</tex>.
Очевидно, что порядок со смещением у второго числа будет таким же, как и у первого.

Второе число положительное, следовательно, бит знака будет содержать ноль.

Итак в машинном 32-разрядном представлении второе число будет иметь вид:

<tex>0</tex>10000111<tex>10010101111000000000011</tex>
Далее в арифметических операциях будет использоваться число <tex>110010101</tex>,<tex>111</tex><tex>2</tex>=<tex>405{,}875</tex><tex>10</tex>, а не <tex>110010101{,}111000000000011</tex><tex>2</tex>=<tex>405{,}87510</tex><tex>10</tex> видимо для упрощения(хотя это не совсем корректно).

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

<tex>1</tex>,<tex>1001010111100</tex><tex>2</tex> <tex>-</tex> <tex>1{,}0000110100111</tex><tex>2</tex> <tex>=</tex> <tex>0{,}1000100010101</tex><tex>2</tex>

Приводим полученный результат к машинному виду. Для этого мы должны внести поправку в порядок {{---}} уменьшить его на единицу.
Знак результата {{---}} положительный, следовательно, бит знака содержит ноль.

<tex>0</tex>10000110<tex>00010001010100000000000</tex>

Проверим правильность наших вычислений. Переведем результат в десятичное представление.

Найдем реальный порядок результата, вычтя из него значение смещения <tex>127</tex><tex>10</tex>.

<tex>E</tex> <tex>=</tex> <tex>10000110</tex><tex>2</tex> <tex>-</tex> <tex>1111111</tex><tex>2</tex> <tex>=</tex> <tex>134</tex><tex>10</tex> <tex>-</tex> <tex>127</tex><tex>10</tex> <tex>=</tex> <tex>7</tex><tex>10</tex> <tex>=</tex> <tex>111</tex><tex>2</tex>

Следовательно, число результата будет иметь вид:
<tex>A</tex> <tex>=</tex> <tex>1{,}000100010101</tex> <tex>×</tex> <tex>10</tex><tex>111</tex> <tex>=</tex> <tex>10001000</tex>,<tex>10101</tex><tex>2</tex> <tex>=</tex> <tex>136{,}65625</tex><tex>10</tex>

Результат наших вычислений верен, так как <tex>405{,}875</tex> - <tex>269{,}21875</tex> <tex>=</tex> <tex>136{,}65625</tex>.

=== Алгоритм получения представления вещественного числа в памяти ЭВМ ===

Покажем преобразование действительного числа для представления его в

памяти ЭВМ на примере величины типа Double.

Как видно из таблицы, величина этого типа занимает в памяти <tex>8</tex> байт. На

рисунке ниже показано, как здесь представлены поля мантиссы и порядка (нумерация битов осуществляется справа налево):

{|class="wikitable"
!Знак || Смещённый порядок || Мантисса
|-
|63 || 62..52 || 51..0
|}

Можно заметить, что старший бит, отведенный под мантиссу, имеет номер

<tex>51</tex>, т.е. мантисса занимает младшие <tex>52</tex> бита. Черта указывает здесь на

положение двоичной запятой. Перед запятой должен стоять бит целой части

мантиссы, но поскольку она всегда равна <tex>1</tex>, здесь данный бит не требуется и

соответствующий разряд отсутствует в памяти (но он подразумевается).

Значение порядка хранится здесь не как целое число, представленное в

дополнительном коде. Для упрощения вычислений и сравнения действительных

чисел значение порядка в ЭВМ хранится в виде смещенного числа, т.е. к

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

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

соответствовал нуль. Например, для типа Double порядок занимает <tex>11</tex> бит и

имеет диапазон от <tex>2</tex><tex>-1023</tex> до <tex>2</tex><tex>1023</tex>, поэтому смещение равно <tex>1023</tex>(<tex>10</tex>) <tex>=</tex>

<tex>1111111111</tex>(<tex>2</tex>). Наконец, бит с номером <tex>63</tex> указывает на знак числа.

Таким образом, из вышесказанного вытекает следующий алгоритм для

получения представления действительного числа в памяти ЭВМ:

<OL>

<LI>перевести модуль данного числа в двоичную систему счисления;</LI>

<LI>нормализовать двоичное число, т.е. записать в виде M × 2p, где M 

мантисса (ее целая часть равна <tex>1</tex>(<tex>2</tex>)) и p  порядок, записанный в

десятичной системе счисления;</LI>

<LI>прибавить к порядку смещение и перевести смещенный порядок в двоичную

систему счисления;</LI>

<LI>учитывая знак заданного числа (0  положительное; 1  отрицательное),

выписать его представление в памяти ЭВМ.</LI>

</OL>

Пример. Запишем код числа <tex>-312</tex>,<tex>3125</tex>.

<OL>

<LI>Двоичная запись модуля этого числа имеет вид <tex>100111000</tex>,<tex>0101</tex>.</LI>

<LI>Имеем <tex>100111000{,}0101</tex> <tex>=</tex>

<tex>1{,}001110000101</tex><tex> × </tex><tex>2</tex><tex>8</tex>.</LI>

<LI>Получаем смещенный порядок <tex>8</tex> <tex>+</tex> <tex>1023</tex> <tex>=</tex> <tex>1031</tex>. Далее имеем

<tex>1031</tex>(<tex>10</tex>) <tex>=</tex> <tex>10000000111</tex>(<tex>2</tex>).</LI>

<LI>Окончательно

{|class="wikitable"
| 1 || 10000000111 || 0011100001010000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

</LI>

</OL>

Очевидно, что более компактно полученный код стоит записать следующим

образом: C073850000000000(16).

Другой пример иллюстрирует обратный переход от кода действительного

числа к самому числу.

Пример. Пусть дан код 3FEC600000000000(16) или

<OL>

{|class="wikitable"
| 0 || 01111111110 || 1100011000000000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

<LI>Прежде всего замечаем, что это код положительного числа, поскольку в

разряде с номером <tex>63</tex> записан нуль. Получим порядок этого числа:

<tex>01111111110</tex>(<tex>2</tex>) <tex>=</tex> <tex>1022</tex>(<tex>10</tex>); <tex>1022</tex> <tex>-</tex> <tex>1023</tex> <tex>=</tex> <tex>-1</tex>.</LI>

<LI>Число имеет вид <tex>1</tex>,<tex>1100011</tex> × <tex>2</tex><tex>-1</tex> или

<tex>0</tex>,<tex>11100011</tex>.</LI>

<LI>Переводом в десятичную систему счисления получаем <tex>0</tex>,<tex>88671875</tex>.</LI>

</OL>

== См. также ==
* [[Представление символов, таблицы кодировок]]
* [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]

== Примечания ==
<references/>

== Ссылки ==
=== Использованные материалы ===
'''На русском'''
* [http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C Википедия {{---}} Экспоненциальная запись]
* [http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D0%B7%D0%B0%D0%BF%D1%8F%D1%82%D0%BE%D0%B9 Википедия {{---}} Число с плавающей запятой]
* [http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%80%D0%B8%D1%86%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BD%D0%BE%D0%BB%D1%8C Википедия {{---}} Отрицательный и положительный ноль]
*[http://habrahabr.ru/blogs/cpp/112953/ Хабрахабр {{---}} статья пользователя Yruslan "Что нужно знать про арифметику с плавающей запятой"]
*[http://www.sgu.ru/prcnit/teach/3.php Статья Лапшевой Е.Е. "Машинная арифметика с вещественными числами"]

'''На английском'''
*[http://en.wikipedia.org/wiki/NaN Wikipedia {{---}} NaN]
*[http://en.wikipedia.org/wiki/Floating_point Wikipedia {{---}} Floating point]
*[http://en.wikipedia.org/wiki/IEEE_754-2008 Wikipedia {{---}} IEEE 754-2008]

=== Что стоит прочесть ===
* [http://grouper.ieee.org/groups/754 Материалы по стандарту IEEE 754 ''(англ.)'']
* [http://softelectro.ru/ieee754.html Русский перевод стандарта IEEE 754]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Представление информации]]

Представление вещественных чисел

2015-01-12T18:53:10Z

Паршуков Кирилл:

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

Число с плавающей запятой состоит из набора отдельных двоичных разрядов, условно разделенных на так называемые '''знак''' (''англ. sign''), '''порядок''' (''англ. exponent'') и '''мантиссу''' (''англ. mantis''). В наиболее распространённом формате (стандарт IEEE 754) число с плавающей запятой представляется в виде набора битов, часть из которых кодирует собой мантиссу числа, другая часть — показатель степени, и ещё один бит используется для указания знака числа (<tex>0</tex> {{---}} если число положительное, <tex>1</tex> {{---}} если число отрицательное). При этом порядок записывается как целое число в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|коде со сдвигом]], а мантисса {{---}} в [[#Нормальная и нормализованная форма|нормализованном виде]], своей дробной частью в двоичной системе счисления. Вот пример такого числа из <tex>16</tex> двоичных разрядов:
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=10 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0

!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Знак {{---}} один бит, указывающий знак всего числа с плавающей точкой. Порядок и мантисса — целые числа, которые вместе со знаком дают представление числа с плавающей запятой в следующем виде:

<tex>(-1)^S \times M \times B^E</tex>, где <tex>S</tex> {{---}} знак, <tex>B</tex> {{---}} основание, <tex>E</tex> {{---}} порядок, а <tex>M</tex> {{---}} мантисса.
Десятичное число, записываемое как <tex> ReE</tex>, где <tex>R</tex> {{---}} число в полуинтервале <tex>[1; 10)</tex>, <tex>E</tex> {{---}} степень, в которой стоит множитель <tex>10</tex>; в нормализированной форме модуль <tex>R</tex> будет являться мантиссой, а <tex>E</tex> {{---}} порядком, а <tex>S</tex> будет равно <tex>1</tex> тогда и только тогда, когда <tex>R</tex> принимает отрицательное значение.
Например, в числе <tex>-2435e9</tex>
* <tex>S</tex> = <tex>1</tex>
* <tex>B</tex> = <tex>10</tex>
* <tex>M</tex> = <tex>2435</tex>
* <tex>E</tex> = <tex>9</tex>

Порядок также иногда называют '''экспонентой''' или просто '''показателем степени'''.


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

Более простым вариантом представления вещественных чисел является вариант с фиксированной точкой, когда целая и вещественная части хранятся отдельно. Например, на целую часть отводится всегда <tex>X</tex> бит и на дробную отводится всегда <tex>Y</tex> бит. Такой способ в архитектурах процессоров не присутствует. Отдаётся предпочтение числам с плавающей запятой, как компромиссу между диапазоном допустимых значений и точностью.

== Нормальная и нормализованная форма ==

'''Нормальной формой''' (''англ. normal form'') числа с плавающей запятой называется такая форма, в которой мантисса (без учёта знака) в десятичной системе находится на полуинтервале <tex>[0; 1)</tex>. Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, <tex>0{,}0001</tex> можно записать в 4 формах — <tex>0{,}0001</tex>×<tex>10</tex><tex>0</tex>, <tex>0{,}001</tex>×<tex>10</tex><tex>−1</tex>, <tex>0{,}01</tex>×<tex>10</tex><tex>−2</tex>, <tex>0{,}1</tex>×<tex>10</tex><tex>−3</tex>), поэтому распространена также другая форма записи — '''нормализованная''' (''англ. normalized''), в которой мантисса десятичного числа принимает значения от <tex>1</tex> (включительно) до <tex>10</tex> (не включительно), а мантисса двоичного числа принимает значения от <tex>1</tex> (включительно) до <tex>2</tex> (не включительно). То есть в мантиссе слева от запятой до применения порядка находится ровно один знак. В такой форме любое число (кроме <tex>0</tex>) записывается единственным образом. Ноль же представить таким образом невозможно, поэтому стандарт предусматривает специальную последовательность битов для задания числа <tex>0</tex> (а заодно и некоторых других [[#Особые значения чисел с плавающей точкой|полезных чисел]], таких как <tex>-\infty</tex> и <tex>+\infty</tex>).
Так как старший двоичный разряд (целая часть) мантиссы вещественного числа в нормализованном виде всегда равен «<tex>1</tex>», то его можно не записывать, сэкономив таким образом один бит, что и используется в стандарте IEEE 754. В позиционных системах счисления с основанием большим, чем <tex>2</tex> (в троичной, четверичной и др.), этого замечательного свойства нет (ведь целая часть там может быть не только единицей).

== Типы чисел с плавающей точкой (по IEEE 754) ==
=== Число половинной точности (''Binary16'', ''Half precision'') ===

'''Число́ полови́нной то́чности''' — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — <tex>16</tex> бит или <tex>2</tex> байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=3 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=2 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=6 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|со сдвигом]] '''<tex>-15</tex>'''. То есть чтобы получить актуально значение порядка нужно вычесть из него сдвиг. Сдвиг можно получить по формуле <tex>2^{b-1}-1</tex>, где <tex>b</tex> {{---}} число бит, отведенное на хранение порядка (в случае числа половинной точности <tex>b=5</tex>).

'''Ограничения точности'''
* Целые от нуля до <tex>2048</tex> передаются как есть.
* Целые от <tex>2049</tex> до <tex>4096</tex> округляются к ближайшему чётному целому.
* Целые от <tex>4097</tex> до <tex>8192</tex> округляются до ближайшего целого, делящегося нацело на четыре.
* Целые от <tex>8193</tex> до <tex>16384</tex> округляются до ближайшего целого, делящегося на восемь.
* Целые от <tex>16385</tex> до <tex>32768</tex> округляются до ближайшего целого, делящегося на шестнадцать.
* Целые от <tex>32769</tex> до <tex>65535</tex> округляются до ближайшего целого, делящегося на тридцать два.

=== Число одинарной точности (''Binary32'', ''Single precision'', ''float'') ===

'''Число́ одина́рной то́чности''' — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — <tex>32</tex> бита или <tex>4</tex> байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.

{|class="wikitable" style="background-color: transparent; border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=8 style="background-color: lightgreen; border: thin solid black"|Порядок (8 бит)
!colspan=24 style="background-color: lightcoral; border: thin solid black"|Мантисса (23+1 бита)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"|
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|30
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|23
|style="border: none"|
|colspan=20 style="border: none; border-left: 1px solid gray; text-align: left"|22
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-127</tex>'''.

=== Число двойной точности (''Binary64'', ''Double precision'', ''double'') ===

'''Число́ двойно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — <tex>64</tex> бита или <tex>8</tex> байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=11 style="background-color: lightgreen; border: thin solid black"|Порядок (11 бит)
!colspan=53 style="background-color: lightcoral; border: thin solid black"|Мантисса (52+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|62
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|52
|style="border: none"|
|colspan=48 style="border: none; border-left: 1px solid gray; text-align: left"|51
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-1023</tex>'''.

=== Число четверной точности (''Binary128'', ''Quadruple precision'') ===

'''Число́ четверно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — <tex>128</tex> бит или <tex>16</tex> байт). Используется в случае необходимости крайне высокой точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=15 style="background-color: lightgreen; border: thin solid black"|Порядок (15 бит)
!colspan=47 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=8 style="border: none; border-left: 1px solid gray; text-align: left"|126
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|112
|style="border: none"|
|colspan=38 style="border: none; border-left: 1px solid gray; text-align: left"|111
|}
 
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=66 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|colspan=66 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-16383</tex>'''.

Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки. Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью).
В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.

=== Диапазон значений чисел с плавающей запятой ===
Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, "не число", получается как результат операций типа деления нуля на ноль) и <tex>\pm\infty</tex>.

Данная таблица только лишь примерно указывает границы допустимых значений, без учета возрастающей погрешности с ростом абсолютного значения и существования [[#Денормализованные числа|денормализованных чисел]].


{| class="wikitable"
!Название в IEEE 754|| Название типа переменной в Си || Диапазон значений || Бит в мантиссе || Бит на переменную
|-
|Half precision||-||6,10×10-5..65504||11||16
|-
|Single presicion||float||3,4×10-38..3,4×1038||23||32
|-
|Double precision||double||1,7×10-308..1,7×10308||53||64
|-
|Extended precision||На некоторых архитектурах (например в сопроцессоре Intel) long double||3,4×10-4932..3,4×104932||65||80
|}

== Особые значения чисел с плавающей точкой ==
=== Ноль (со знаком) ===
Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль. Поэтому для его представления зарезервированы специальные значения мантиссы и порядка {{---}} число считается нулём, если все его биты, кроме знакового, равны нулю. При этом в зависимости от значения бита знака ноль может быть как положительным, так и отрицательным.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm0</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

'''Арифметика нуля со знаком'''
 
Арифметика отрицательного нуля аналогична таковой для любого отрицательного числа и понятна интуитивно. Вот несколько примеров:

* <tex>\frac{-0}{ \left| x \right| } = -0\,\!</tex> (если <tex>x\ne0</tex>)

* <tex>(-0) \cdot (-0) = +0\,\!</tex>

* <tex>\left| x \right| \cdot (-0) = -0\,\!</tex>

* <tex>x + (\pm 0) = x\,\!</tex>

* <tex>(-0) + (-0) = -0\,\!</tex>

* <tex>(+0) + (+0) = +0\,\!</tex>

* <tex>\frac{-0}{-\infty} = +0\,\!</tex>

* <tex>\frac{\left|x\right|}{-0} = -\infty\,\!</tex> (если <tex>x\ne0</tex>)

=== Неопределенность (''NaN'') ===
'''NaN''' {{---}} это аббревиатура от фразы "''not a number''". NaN является результатом арифметических операций, если во время их выполнения произошла ошибка (примеры см. ниже). В IEEE 754 NaN представлен как число, в котором все двоичные разряды порядка {{---}} единицы, а мантисса не нулевая.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: transparent; border: none"| = <tex>NaN</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.

'''Как можно получить NaN?'''
 

* <tex>\infty+(-\infty)= NaN</tex>

* <tex>0\times\infty= NaN</tex>

* <tex>\frac{\pm0}{\pm0}=\frac{\pm\infty}{\pm\infty} = NaN</tex>

* <tex>\sqrt{x} = NaN</tex>, где <tex>x<0</tex>

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

По определению NaN ≠ NaN, поэтому, для проверки значения переменной нужно просто сравнить ее с собой.


=== Бесконечности ===
В число с плавающей запятой можно записать значение <tex>+\infty</tex> или <tex>-\infty</tex>. Как и нули со знаком, бесконечности позволяют получить хотя бы близкий к правильному результат вычисления в случае переполнения. Согласно стандарту IEEE 754 число с плавающей запятой считается равным бесконечности, если все двоичные разряды его порядка {{---}} единицы, а мантисса равна нулю. Знак бесконечности определяется знаковым битом числа.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm\infty</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Получить бесконечность можно при переполнении и при делении ненулевого числа на ноль. При этом
<tex dpi = "180">
\frac{x}{0}
</tex>
<tex>=
\begin{cases}
+\infty,&\text{если $x>0$;}\\
NaN,&\text{если $x=0$;}\\
-\infty,&\text{если $x<0$.}
\end{cases}

</tex>

=== Денормализованные числа ===
'''Денормализованные числа''' (''англ. denormalized/subnormal numbers'') - это способ увеличить количество представимых числом с плавающей запятой значений около нуля, дабы повысить точность вычислений. Каждое значение денормализованного числа меньше самого маленького '''нормализованного''' ("обычного") значения числа с плавающей запятой.
Согласно стандарту, если порядок равен своему минимальному значению (все его биты {{---}} нули, а истинное значение порядка равно его сдвигу) и все биты мантиссы равны нулю, то это <tex>\pm0</tex>. Если же мантисса не равна нулю, то это число с порядком, на единицу большим минимального (все биты порядка, кроме младшего {{---}} нули) и данной мантиссой, '''целая часть которой считается равной нулю, а не единице'''.

То есть число с плавающей запятой, при учете вышесказанного, можно задать следующим образом:
 
* <tex>(-1)^s\times1.M\times2^E</tex>, если <tex>E_{min} \le E \le E_{max}</tex> (''нормализованное число'')

* <tex>(-1)^s\times0.M\times2^{E_{min}}</tex>, если <tex>E=E_{min}-1</tex> (''денормализованное число'')

Где <tex>s</tex> {{---}} бит знака, <tex>M</tex> {{---}} последовательность битов мантиссы, <tex>E</tex> {{---}} значение порядка (с учетом сдвига), <tex>E_{min}</tex> {{---}} минимальное значение порядка, используемое для записи чисел (1 {{---}} ''сдвиг'') , <tex>E_{min}-1</tex> {{---}} минимальное значение порядка, которое он в принципе может принять (все биты нули, 0 {{---}} ''сдвиг'').

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

В современных процессорах обработка денормализованных чисел происходит в десятки раз медленнее, чем обработка нормализованных чисел. Ниже приведена часть таблицы из статьи Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values"<ref>[http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf Статья Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values" ''(англ.)'']</ref>

{| class="wikitable"
!Производитель||Процессор||Замедление (разы)
|-
|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-х разрядном формате <tex>-269</tex> <tex>7</tex>/<tex>32</tex> и <tex>405,875</tex>.
Переведем <tex>-269</tex> <tex>7</tex>/<tex>32</tex> в машинный вид. Для этого сначала переведем его в двоичную систему счисления.
<tex>-269</tex> <tex>7</tex>/<tex>32</tex> = <tex>-269,21875</tex>
<tex>-269,21875</tex><tex>10</tex> = <tex>-100001101,00111</tex><tex>2</tex>

Нормализуем полученное двоичное число по правилам машинной арифметики.
<tex>-100001101{,}00111</tex> = <tex>-1{,}0000110100111</tex> × <tex>10</tex><tex>1000</tex>

Найдем смещенный порядок. Так как в условии говорится о 32-разрядном представлении, то смещение порядка равно <tex>127</tex><tex>10</tex>.
E = <tex>8</tex><tex>10</tex> + <tex>127</tex><tex>10</tex> = <tex>1000</tex><tex>2</tex> + <tex>1111111</tex><tex>2</tex> = <tex>10000111</tex><tex>2</tex>

Число отрицательное, следовательно, в бите знака будет стоять единица.

Итак, первое число в машинном 32-разрядном представлении с плавающей точкой будет иметь вид:
<tex>1</tex>10000111<tex>00001101001110000000000</tex> (жирным шрифтом выделен порядок числа, длина мантиссы {{---}} 23 бита).

Переведем второе число в машинный вид, совершая те же действия.

<tex>405,87510</tex> = <tex>110010101</tex>,<tex>111000000000011010</tex>...<tex>2</tex> = <tex>1,10010101111000000000011010</tex>... × <tex>10</tex><tex>1000</tex>
В качестве мантиссы будут сохранены первые <tex>23</tex> бита после запятой т.е. <tex>10010101111000000000011</tex>.
Очевидно, что порядок со смещением у второго числа будет таким же, как и у первого.

Второе число положительное, следовательно, бит знака будет содержать ноль.

Итак в машинном 32-разрядном представлении второе число будет иметь вид:

<tex>0</tex>10000111<tex>10010101111000000000011</tex>
Далее в арифметических операциях будет использоваться число <tex>110010101</tex>,<tex>111</tex><tex>2</tex>=<tex>405</tex>.<tex>875</tex><tex>10</tex>, а не <tex>110010101</tex>,<tex>111000000000011</tex><tex>2</tex>=<tex>405</tex>,<tex>87510</tex><tex>10</tex> видимо для упрощения(хотя это не совсем корректно).

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

<tex>1</tex>,<tex>1001010111100</tex><tex>2</tex> - <tex>1</tex>,<tex>0000110100111</tex><tex>2</tex> = <tex>0</tex>,<tex>1000100010101</tex><tex>2</tex>

Приводим полученный результат к машинному виду. Для этого мы должны внести поправку в порядок {{---}} уменьшить его на единицу.
Знак результата {{---}} положительный, следовательно, бит знака содержит ноль.

<tex>0</tex>10000110<tex>00010001010100000000000</tex>

Проверим правильность наших вычислений. Переведем результат в десятичное представление.

Найдем реальный порядок результата, вычтя из него значение смещения <tex>127</tex><tex>10</tex>.

E = <tex>10000110</tex><tex>2</tex> - <tex>1111111</tex><tex>2</tex> = <tex>134</tex><tex>10</tex> - <tex>127</tex><tex>10</tex> = <tex>7</tex><tex>10</tex> = <tex>111</tex><tex>2</tex>

Следовательно, число результата будет иметь вид:
A = <tex>1</tex>,<tex>000100010101</tex> × <tex>10</tex><tex>111</tex> = <tex>10001000</tex>,<tex>10101</tex><tex>2</tex> = <tex>136</tex>,<tex>65625</tex><tex>10</tex>

Результат наших вычислений верен, так как <tex>405</tex>,<tex>875</tex> - <tex>269</tex>,<tex>21875</tex> = <tex>136</tex>,<tex>65625</tex>.

=== Алгоритм получения представления вещественного числа в памяти ЭВМ ===

Покажем преобразование действительного числа для представления его в

памяти ЭВМ на примере величины типа Double.

Как видно из таблицы, величина этого типа занимает в памяти <tex>8</tex> байт. На

рисунке ниже показано, как здесь представлены поля мантиссы и порядка (нумерация битов осуществляется справа налево):

{|class="wikitable"
!Знак || Смещённый порядок || Мантисса
|-
|63 || 62..52 || 51..0
|}

Можно заметить, что старший бит, отведенный под мантиссу, имеет номер

<tex>51</tex>, т.е. мантисса занимает младшие <tex>52</tex> бита. Черта указывает здесь на

положение двоичной запятой. Перед запятой должен стоять бит целой части

мантиссы, но поскольку она всегда равна <tex>1</tex>, здесь данный бит не требуется и

соответствующий разряд отсутствует в памяти (но он подразумевается).

Значение порядка хранится здесь не как целое число, представленное в

дополнительном коде. Для упрощения вычислений и сравнения действительных

чисел значение порядка в ЭВМ хранится в виде смещенного числа, т.е. к

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

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

соответствовал нуль. Например, для типа Double порядок занимает <tex>11</tex> бит и

имеет диапазон от <tex>2</tex><tex>-1023</tex> до <tex>2</tex><tex>1023</tex>, поэтому смещение равно <tex>1023</tex>(<tex>10</tex>) =

<tex>1111111111</tex>(<tex>2</tex>). Наконец, бит с номером <tex>63</tex> указывает на знак числа.

Таким образом, из вышесказанного вытекает следующий алгоритм для

получения представления действительного числа в памяти ЭВМ:

<OL>

<LI>перевести модуль данного числа в двоичную систему счисления;</LI>

<LI>нормализовать двоичное число, т.е. записать в виде M × 2p, где M 

мантисса (ее целая часть равна <tex>1</tex>(<tex>2</tex>)) и p  порядок, записанный в

десятичной системе счисления;</LI>

<LI>прибавить к порядку смещение и перевести смещенный порядок в двоичную

систему счисления;</LI>

<LI>учитывая знак заданного числа (0  положительное; 1  отрицательное),

выписать его представление в памяти ЭВМ.</LI>

</OL>

Пример. Запишем код числа <tex>-312</tex>,<tex>3125</tex>.

<OL>

<LI>Двоичная запись модуля этого числа имеет вид <tex>100111000</tex>,<tex>0101</tex>.</LI>

<LI>Имеем <tex>100111000</tex>,<tex>0101</tex> =

<tex>1</tex>,<tex>001110000101</tex> × <tex>2</tex><tex>8</tex>.</LI>

<LI>Получаем смещенный порядок <tex>8</tex> + <tex>1023</tex> = <tex>1031</tex>. Далее имеем

<tex>1031</tex>(<tex>10</tex>) = <tex>10000000111</tex>(<tex>2</tex>).</LI>

<LI>Окончательно

{|class="wikitable"
| 1 || 10000000111 || 0011100001010000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

</LI>

</OL>

Очевидно, что более компактно полученный код стоит записать следующим

образом: C073850000000000(16).

Другой пример иллюстрирует обратный переход от кода действительного

числа к самому числу.

Пример. Пусть дан код 3FEC600000000000(16) или

<OL>

{|class="wikitable"
| 0 || 01111111110 || 1100011000000000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

<LI>Прежде всего замечаем, что это код положительного числа, поскольку в

разряде с номером <tex>63</tex> записан нуль. Получим порядок этого числа:

<tex>01111111110</tex>(<tex>2</tex>) = <tex>1022</tex>(<tex>10</tex>); <tex>1022</tex> - <tex>1023</tex> = <tex>-1</tex>.</LI>

<LI>Число имеет вид <tex>1</tex>,<tex>1100011</tex> × <tex>2</tex><tex>-1</tex> или

<tex>0</tex>,<tex>11100011</tex>.</LI>

<LI>Переводом в десятичную систему счисления получаем <tex>0</tex>,<tex>88671875</tex>.</LI>

</OL>

== См. также ==
* [[Представление символов, таблицы кодировок]]
* [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]

== Примечания ==
<references/>

== Ссылки ==
=== Использованные материалы ===
'''На русском'''
* [http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C Википедия {{---}} Экспоненциальная запись]
* [http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D0%B7%D0%B0%D0%BF%D1%8F%D1%82%D0%BE%D0%B9 Википедия {{---}} Число с плавающей запятой]
* [http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%80%D0%B8%D1%86%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BD%D0%BE%D0%BB%D1%8C Википедия {{---}} Отрицательный и положительный ноль]
*[http://habrahabr.ru/blogs/cpp/112953/ Хабрахабр {{---}} статья пользователя Yruslan "Что нужно знать про арифметику с плавающей запятой"]
*[http://www.sgu.ru/prcnit/teach/3.php Статья Лапшевой Е.Е. "Машинная арифметика с вещественными числами"]

'''На английском'''
*[http://en.wikipedia.org/wiki/NaN Wikipedia {{---}} NaN]
*[http://en.wikipedia.org/wiki/Floating_point Wikipedia {{---}} Floating point]
*[http://en.wikipedia.org/wiki/IEEE_754-2008 Wikipedia {{---}} IEEE 754-2008]

=== Что стоит прочесть ===
* [http://grouper.ieee.org/groups/754 Материалы по стандарту IEEE 754 ''(англ.)'']
* [http://softelectro.ru/ieee754.html Русский перевод стандарта IEEE 754]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Представление информации]]

Представление вещественных чисел

2015-01-12T18:22:16Z

Паршуков Кирилл:

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

Число с плавающей запятой состоит из набора отдельных двоичных разрядов, условно разделенных на так называемые '''знак''' (''англ. sign''), '''порядок''' (''англ. exponent'') и '''мантиссу''' (''англ. mantis''). В наиболее распространённом формате (стандарт IEEE 754) число с плавающей запятой представляется в виде набора битов, часть из которых кодирует собой мантиссу числа, другая часть — показатель степени, и ещё один бит используется для указания знака числа (<tex>0</tex> {{---}} если число положительное, <tex>1</tex> {{---}} если число отрицательное). При этом порядок записывается как целое число в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|коде со сдвигом]], а мантисса {{---}} в [[#Нормальная и нормализованная форма|нормализованном виде]], своей дробной частью в двоичной системе счисления. Вот пример такого числа из <tex>16</tex> двоичных разрядов:
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=10 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0

!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Знак {{---}} один бит, указывающий знак всего числа с плавающей точкой. Порядок и мантисса — целые числа, которые вместе со знаком дают представление числа с плавающей запятой в следующем виде:

<tex>(-1)^S \times M \times B^E</tex>, где <tex>S</tex> {{---}} знак, <tex>B</tex> {{---}} основание, <tex>E</tex> {{---}} порядок, а <tex>M</tex> {{---}} мантисса.
Десятичное число, записываемое как <tex> ReE</tex>, где <tex>R</tex> {{---}} число в полуинтервале <tex>[1; 10)</tex>, <tex>E</tex> {{---}} степень, в которой стоит множитель <tex>10</tex>; в нормализированной форме модуль <tex>R</tex> будет являться мантиссой, а <tex>E</tex> {{---}} порядком, а <tex>S</tex> будет равно <tex>1</tex> тогда и только тогда, когда <tex>R</tex> принимает отрицательное значение.
Например, в числе <tex>-2435e9</tex>
* <tex>S</tex> = <tex>1</tex>
* <tex>B</tex> = <tex>10</tex>
* <tex>M</tex> = <tex>2435</tex>
* <tex>E</tex> = <tex>9</tex>

Порядок также иногда называют '''экспонентой''' или просто '''показателем степени'''.


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

Так же используется формат хранения чисел с фиксированной точкой, который используется для неточных расчётов. Очевидно, что степень числа не хранится в оперативной памяти, а выделяется место для хранения целого числа. Порядок же задаётся программистом.

== Нормальная и нормализованная форма ==

'''Нормальной формой''' (''англ. normal form'') числа с плавающей запятой называется такая форма, в которой мантисса (без учёта знака) в десятичной системе находится на полуинтервале <tex>[0; 1)</tex>. Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, <tex>0{,}0001</tex> можно записать в 4 формах — <tex>0{,}0001</tex>×<tex>10</tex><tex>0</tex>, <tex>0{,}001</tex>×<tex>10</tex><tex>−1</tex>, <tex>0{,}01</tex>×<tex>10</tex><tex>−2</tex>, <tex>0{,}1</tex>×<tex>10</tex><tex>−3</tex>), поэтому распространена также другая форма записи — '''нормализованная''' (''англ. normalized''), в которой мантисса десятичного числа принимает значения от <tex>1</tex> (включительно) до <tex>10</tex> (не включительно), а мантисса двоичного числа принимает значения от <tex>1</tex> (включительно) до <tex>2</tex> (не включительно). То есть в мантиссе слева от запятой до применения порядка находится ровно один знак. В такой форме любое число (кроме <tex>0</tex>) записывается единственным образом. Ноль же представить таким образом невозможно, поэтому стандарт предусматривает специальную последовательность битов для задания числа <tex>0</tex> (а заодно и некоторых других [[#Особые значения чисел с плавающей точкой|полезных чисел]], таких как <tex>-\infty</tex> и <tex>+\infty</tex>).
Так как старший двоичный разряд (целая часть) мантиссы вещественного числа в нормализованном виде всегда равен «<tex>1</tex>», то его можно не записывать, сэкономив таким образом один бит, что и используется в стандарте IEEE 754. В позиционных системах счисления с основанием большим, чем <tex>2</tex> (в троичной, четверичной и др.), этого замечательного свойства нет (ведь целая часть там может быть не только единицей).

== Типы чисел с плавающей точкой (по IEEE 754) ==
=== Число половинной точности (''Binary16'', ''Half precision'') ===

'''Число́ полови́нной то́чности''' — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — <tex>16</tex> бит или <tex>2</tex> байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=3 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=2 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=6 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|со сдвигом]] '''<tex>-15</tex>'''. То есть чтобы получить актуально значение порядка нужно вычесть из него сдвиг. Сдвиг можно получить по формуле <tex>2^{b-1}-1</tex>, где <tex>b</tex> {{---}} число бит, отведенное на хранение порядка (в случае числа половинной точности <tex>b=5</tex>).

'''Ограничения точности'''
* Целые от нуля до <tex>2048</tex> передаются как есть.
* Целые от <tex>2049</tex> до <tex>4096</tex> округляются к ближайшему чётному целому.
* Целые от <tex>4097</tex> до <tex>8192</tex> округляются до ближайшего целого, делящегося нацело на четыре.
* Целые от <tex>8193</tex> до <tex>16384</tex> округляются до ближайшего целого, делящегося на восемь.
* Целые от <tex>16385</tex> до <tex>32768</tex> округляются до ближайшего целого, делящегося на шестнадцать.
* Целые от <tex>32769</tex> до <tex>65535</tex> округляются до ближайшего целого, делящегося на тридцать два.

=== Число одинарной точности (''Binary32'', ''Single precision'', ''float'') ===

'''Число́ одина́рной то́чности''' — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — <tex>32</tex> бита или <tex>4</tex> байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.

{|class="wikitable" style="background-color: transparent; border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=8 style="background-color: lightgreen; border: thin solid black"|Порядок (8 бит)
!colspan=24 style="background-color: lightcoral; border: thin solid black"|Мантисса (23+1 бита)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"|
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|30
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|23
|style="border: none"|
|colspan=20 style="border: none; border-left: 1px solid gray; text-align: left"|22
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-127</tex>'''.

=== Число двойной точности (''Binary64'', ''Double precision'', ''double'') ===

'''Число́ двойно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — <tex>64</tex> бита или <tex>8</tex> байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=11 style="background-color: lightgreen; border: thin solid black"|Порядок (11 бит)
!colspan=53 style="background-color: lightcoral; border: thin solid black"|Мантисса (52+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|62
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|52
|style="border: none"|
|colspan=48 style="border: none; border-left: 1px solid gray; text-align: left"|51
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-1023</tex>'''.

=== Число четверной точности (''Binary128'', ''Quadruple precision'') ===

'''Число́ четверно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — <tex>128</tex> бит или <tex>16</tex> байт). Используется в случае необходимости крайне высокой точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=15 style="background-color: lightgreen; border: thin solid black"|Порядок (15 бит)
!colspan=47 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=8 style="border: none; border-left: 1px solid gray; text-align: left"|126
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|112
|style="border: none"|
|colspan=38 style="border: none; border-left: 1px solid gray; text-align: left"|111
|}
 
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=66 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|colspan=66 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-16383</tex>'''.

Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки. Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью).
В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.

=== Диапазон значений чисел с плавающей запятой ===
Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, "не число", получается как результат операций типа деления нуля на ноль) и <tex>\pm\infty</tex>.

Данная таблица только лишь примерно указывает границы допустимых значений, без учета возрастающей погрешности с ростом абсолютного значения и существования [[#Денормализованные числа|денормализованных чисел]].


{| class="wikitable"
!Название в IEEE 754|| Название типа переменной в Си || Диапазон значений || Бит в мантиссе || Бит на переменную
|-
|Half precision||-||6,10×10-5..65504||11||16
|-
|Single presicion||float||3,4×10-38..3,4×1038||23||32
|-
|Double precision||double||1,7×10-308..1,7×10308||53||64
|-
|Extended precision||На некоторых архитектурах (например в сопроцессоре Intel) long double||3,4×10-4932..3,4×104932||65||80
|}

== Особые значения чисел с плавающей точкой ==
=== Ноль (со знаком) ===
Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль. Поэтому для его представления зарезервированы специальные значения мантиссы и порядка {{---}} число считается нулём, если все его биты, кроме знакового, равны нулю. При этом в зависимости от значения бита знака ноль может быть как положительным, так и отрицательным.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm0</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

'''Арифметика нуля со знаком'''
 
Арифметика отрицательного нуля аналогична таковой для любого отрицательного числа и понятна интуитивно. Вот несколько примеров:

* <tex>\frac{-0}{ \left| x \right| } = -0\,\!</tex> (если <tex>x\ne0</tex>)

* <tex>(-0) \cdot (-0) = +0\,\!</tex>

* <tex>\left| x \right| \cdot (-0) = -0\,\!</tex>

* <tex>x + (\pm 0) = x\,\!</tex>

* <tex>(-0) + (-0) = -0\,\!</tex>

* <tex>(+0) + (+0) = +0\,\!</tex>

* <tex>\frac{-0}{-\infty} = +0\,\!</tex>

* <tex>\frac{\left|x\right|}{-0} = -\infty\,\!</tex> (если <tex>x\ne0</tex>)

=== Неопределенность (''NaN'') ===
'''NaN''' {{---}} это аббревиатура от фразы "''not a number''". NaN является результатом арифметических операций, если во время их выполнения произошла ошибка (примеры см. ниже). В IEEE 754 NaN представлен как число, в котором все двоичные разряды порядка {{---}} единицы, а мантисса не нулевая.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: transparent; border: none"| = <tex>NaN</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.

'''Как можно получить NaN?'''
 

* <tex>\infty+(-\infty)= NaN</tex>

* <tex>0\times\infty= NaN</tex>

* <tex>\frac{\pm0}{\pm0}=\frac{\pm\infty}{\pm\infty} = NaN</tex>

* <tex>\sqrt{x} = NaN</tex>, где <tex>x<0</tex>

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

По определению NaN ≠ NaN, поэтому, для проверки значения переменной нужно просто сравнить ее с собой.


=== Бесконечности ===
В число с плавающей запятой можно записать значение <tex>+\infty</tex> или <tex>-\infty</tex>. Как и нули со знаком, бесконечности позволяют получить хотя бы близкий к правильному результат вычисления в случае переполнения. Согласно стандарту IEEE 754 число с плавающей запятой считается равным бесконечности, если все двоичные разряды его порядка {{---}} единицы, а мантисса равна нулю. Знак бесконечности определяется знаковым битом числа.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm\infty</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Получить бесконечность можно при переполнении и при делении ненулевого числа на ноль. При этом
<tex dpi = "180">
\frac{x}{0}
</tex>
<tex>=
\begin{cases}
+\infty,&\text{если $x>0$;}\\
NaN,&\text{если $x=0$;}\\
-\infty,&\text{если $x<0$.}
\end{cases}

</tex>

=== Денормализованные числа ===
'''Денормализованные числа''' (''англ. denormalized/subnormal numbers'') - это способ увеличить количество представимых числом с плавающей запятой значений около нуля, дабы повысить точность вычислений. Каждое значение денормализованного числа меньше самого маленького '''нормализованного''' ("обычного") значения числа с плавающей запятой.
Согласно стандарту, если порядок равен своему минимальному значению (все его биты {{---}} нули, а истинное значение порядка равно его сдвигу) и все биты мантиссы равны нулю, то это <tex>\pm0</tex>. Если же мантисса не равна нулю, то это число с порядком, на единицу большим минимального (все биты порядка, кроме младшего {{---}} нули) и данной мантиссой, '''целая часть которой считается равной нулю, а не единице'''.

То есть число с плавающей запятой, при учете вышесказанного, можно задать следующим образом:
 
* <tex>(-1)^s\times1.M\times2^E</tex>, если <tex>E_{min} \le E \le E_{max}</tex> (''нормализованное число'')

* <tex>(-1)^s\times0.M\times2^{E_{min}}</tex>, если <tex>E=E_{min}-1</tex> (''денормализованное число'')

Где <tex>s</tex> {{---}} бит знака, <tex>M</tex> {{---}} последовательность битов мантиссы, <tex>E</tex> {{---}} значение порядка (с учетом сдвига), <tex>E_{min}</tex> {{---}} минимальное значение порядка, используемое для записи чисел (1 {{---}} ''сдвиг'') , <tex>E_{min}-1</tex> {{---}} минимальное значение порядка, которое он в принципе может принять (все биты нули, 0 {{---}} ''сдвиг'').

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

В современных процессорах обработка денормализованных чисел происходит в десятки раз медленнее, чем обработка нормализованных чисел. Ниже приведена часть таблицы из статьи Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values"<ref>[http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf Статья Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values" ''(англ.)'']</ref>

{| class="wikitable"
!Производитель||Процессор||Замедление (разы)
|-
|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-х разрядном формате <tex>-269</tex> <tex>7</tex>/<tex>32</tex> и <tex>405,875</tex>.
Переведем <tex>-269</tex> <tex>7</tex>/<tex>32</tex> в машинный вид. Для этого сначала переведем его в двоичную систему счисления.
<tex>-269</tex> <tex>7</tex>/<tex>32</tex> = <tex>-269,21875</tex>
<tex>-269,21875</tex><tex>10</tex> = <tex>-100001101,00111</tex><tex>2</tex>

Нормализуем полученное двоичное число по правилам машинной арифметики.
<tex>-100001101{,}00111</tex> = <tex>-1{,}0000110100111</tex> × <tex>10</tex><tex>1000</tex>

Найдем смещенный порядок. Так как в условии говорится о 32-разрядном представлении, то смещение порядка равно <tex>127</tex><tex>10</tex>.
E = <tex>8</tex><tex>10</tex> + <tex>127</tex><tex>10</tex> = <tex>1000</tex><tex>2</tex> + <tex>1111111</tex><tex>2</tex> = <tex>10000111</tex><tex>2</tex>

Число отрицательное, следовательно, в бите знака будет стоять единица.

Итак, первое число в машинном 32-разрядном представлении с плавающей точкой будет иметь вид:
<tex>1</tex>10000111<tex>00001101001110000000000</tex> (жирным шрифтом выделен порядок числа, длина мантиссы {{---}} 23 бита).

Переведем второе число в машинный вид, совершая те же действия.

<tex>405,87510</tex> = <tex>110010101</tex>,<tex>111000000000011010</tex>...<tex>2</tex> = <tex>1,10010101111000000000011010</tex>... × <tex>10</tex><tex>1000</tex>
В качестве мантиссы будут сохранены первые <tex>23</tex> бита после запятой т.е. <tex>10010101111000000000011</tex>.
Очевидно, что порядок со смещением у второго числа будет таким же, как и у первого.

Второе число положительное, следовательно, бит знака будет содержать ноль.

Итак в машинном 32-разрядном представлении второе число будет иметь вид:

<tex>0</tex>10000111<tex>10010101111000000000011</tex>
Далее в арифметических операциях будет использоваться число <tex>110010101</tex>,<tex>111</tex><tex>2</tex>=<tex>405</tex>.<tex>875</tex><tex>10</tex>, а не <tex>110010101</tex>,<tex>111000000000011</tex><tex>2</tex>=<tex>405</tex>,<tex>87510</tex><tex>10</tex> видимо для упрощения(хотя это не совсем корректно).

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

<tex>1</tex>,<tex>1001010111100</tex><tex>2</tex> - <tex>1</tex>,<tex>0000110100111</tex><tex>2</tex> = <tex>0</tex>,<tex>1000100010101</tex><tex>2</tex>

Приводим полученный результат к машинному виду. Для этого мы должны внести поправку в порядок {{---}} уменьшить его на единицу.
Знак результата {{---}} положительный, следовательно, бит знака содержит ноль.

<tex>0</tex>10000110<tex>00010001010100000000000</tex>

Проверим правильность наших вычислений. Переведем результат в десятичное представление.

Найдем реальный порядок результата, вычтя из него значение смещения <tex>127</tex><tex>10</tex>.

E = <tex>10000110</tex><tex>2</tex> - <tex>1111111</tex><tex>2</tex> = <tex>134</tex><tex>10</tex> - <tex>127</tex><tex>10</tex> = <tex>7</tex><tex>10</tex> = <tex>111</tex><tex>2</tex>

Следовательно, число результата будет иметь вид:
A = <tex>1</tex>,<tex>000100010101</tex> × <tex>10</tex><tex>111</tex> = <tex>10001000</tex>,<tex>10101</tex><tex>2</tex> = <tex>136</tex>,<tex>65625</tex><tex>10</tex>

Результат наших вычислений верен, так как <tex>405</tex>,<tex>875</tex> - <tex>269</tex>,<tex>21875</tex> = <tex>136</tex>,<tex>65625</tex>.

=== Алгоритм получения представления вещественного числа в памяти ЭВМ ===

Покажем преобразование действительного числа для представления его в

памяти ЭВМ на примере величины типа Double.

Как видно из таблицы, величина этого типа занимает в памяти <tex>8</tex> байт. На

рисунке ниже показано, как здесь представлены поля мантиссы и порядка (нумерация битов осуществляется справа налево):

{|class="wikitable"
!Знак || Смещённый порядок || Мантисса
|-
|63 || 62..52 || 51..0
|}

Можно заметить, что старший бит, отведенный под мантиссу, имеет номер

<tex>51</tex>, т.е. мантисса занимает младшие <tex>52</tex> бита. Черта указывает здесь на

положение двоичной запятой. Перед запятой должен стоять бит целой части

мантиссы, но поскольку она всегда равна <tex>1</tex>, здесь данный бит не требуется и

соответствующий разряд отсутствует в памяти (но он подразумевается).

Значение порядка хранится здесь не как целое число, представленное в

дополнительном коде. Для упрощения вычислений и сравнения действительных

чисел значение порядка в ЭВМ хранится в виде смещенного числа, т.е. к

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

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

соответствовал нуль. Например, для типа Double порядок занимает <tex>11</tex> бит и

имеет диапазон от <tex>2</tex><tex>-1023</tex> до <tex>2</tex><tex>1023</tex>, поэтому смещение равно <tex>1023</tex>(<tex>10</tex>) =

<tex>1111111111</tex>(<tex>2</tex>). Наконец, бит с номером <tex>63</tex> указывает на знак числа.

Таким образом, из вышесказанного вытекает следующий алгоритм для

получения представления действительного числа в памяти ЭВМ:

<OL>

<LI>перевести модуль данного числа в двоичную систему счисления;</LI>

<LI>нормализовать двоичное число, т.е. записать в виде M × 2p, где M 

мантисса (ее целая часть равна <tex>1</tex>(<tex>2</tex>)) и p  порядок, записанный в

десятичной системе счисления;</LI>

<LI>прибавить к порядку смещение и перевести смещенный порядок в двоичную

систему счисления;</LI>

<LI>учитывая знак заданного числа (0  положительное; 1  отрицательное),

выписать его представление в памяти ЭВМ.</LI>

</OL>

Пример. Запишем код числа <tex>-312</tex>,<tex>3125</tex>.

<OL>

<LI>Двоичная запись модуля этого числа имеет вид <tex>100111000</tex>,<tex>0101</tex>.</LI>

<LI>Имеем <tex>100111000</tex>,<tex>0101</tex> =

<tex>1</tex>,<tex>001110000101</tex> × <tex>2</tex><tex>8</tex>.</LI>

<LI>Получаем смещенный порядок <tex>8</tex> + <tex>1023</tex> = <tex>1031</tex>. Далее имеем

<tex>1031</tex>(<tex>10</tex>) = <tex>10000000111</tex>(<tex>2</tex>).</LI>

<LI>Окончательно

{|class="wikitable"
| 1 || 10000000111 || 0011100001010000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

</LI>

</OL>

Очевидно, что более компактно полученный код стоит записать следующим

образом: C073850000000000(16).

Другой пример иллюстрирует обратный переход от кода действительного

числа к самому числу.

Пример. Пусть дан код 3FEC600000000000(16) или

<OL>

{|class="wikitable"
| 0 || 01111111110 || 1100011000000000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

<LI>Прежде всего замечаем, что это код положительного числа, поскольку в

разряде с номером <tex>63</tex> записан нуль. Получим порядок этого числа:

<tex>01111111110</tex>(<tex>2</tex>) = <tex>1022</tex>(<tex>10</tex>); <tex>1022</tex> - <tex>1023</tex> = <tex>-1</tex>.</LI>

<LI>Число имеет вид <tex>1</tex>,<tex>1100011</tex> × <tex>2</tex><tex>-1</tex> или

<tex>0</tex>,<tex>11100011</tex>.</LI>

<LI>Переводом в десятичную систему счисления получаем <tex>0</tex>,<tex>88671875</tex>.</LI>

</OL>

== См. также ==
* [[Представление символов, таблицы кодировок]]
* [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]

== Примечания ==
<references/>

== Ссылки ==
=== Использованные материалы ===
'''На русском'''
* [http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C Википедия {{---}} Экспоненциальная запись]
* [http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D0%B7%D0%B0%D0%BF%D1%8F%D1%82%D0%BE%D0%B9 Википедия {{---}} Число с плавающей запятой]
* [http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%80%D0%B8%D1%86%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BD%D0%BE%D0%BB%D1%8C Википедия {{---}} Отрицательный и положительный ноль]
*[http://habrahabr.ru/blogs/cpp/112953/ Хабрахабр {{---}} статья пользователя Yruslan "Что нужно знать про арифметику с плавающей запятой"]
*[http://www.sgu.ru/prcnit/teach/3.php Статья Лапшевой Е.Е. "Машинная арифметика с вещественными числами"]

'''На английском'''
*[http://en.wikipedia.org/wiki/NaN Wikipedia {{---}} NaN]
*[http://en.wikipedia.org/wiki/Floating_point Wikipedia {{---}} Floating point]
*[http://en.wikipedia.org/wiki/IEEE_754-2008 Wikipedia {{---}} IEEE 754-2008]

=== Что стоит прочесть ===
* [http://grouper.ieee.org/groups/754 Материалы по стандарту IEEE 754 ''(англ.)'']
* [http://softelectro.ru/ieee754.html Русский перевод стандарта IEEE 754]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Представление информации]]

Представление вещественных чисел

2015-01-12T18:03:32Z

Паршуков Кирилл:

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

Число с плавающей запятой состоит из набора отдельных двоичных разрядов, условно разделенных на так называемые '''знак''' (''sign''), '''порядок''' (''exponent'') и '''мантиссу''' (''mantis''). В наиболее распространённом формате (стандарт IEEE 754) число с плавающей запятой представляется в виде набора битов, часть из которых кодирует собой мантиссу числа, другая часть — показатель степени, и ещё один бит используется для указания знака числа (<tex>0</tex> {{---}} если число положительное, <tex>1</tex> {{---}} если число отрицательное). При этом порядок записывается как целое число в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|коде со сдвигом]], а мантисса {{---}} в [[#Нормальная и нормализованная форма|нормализованном виде]], своей дробной частью в двоичной системе счисления. Вот пример такого числа из <tex>16</tex> двоичных разрядов:
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=10 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0

!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Знак {{---}} один бит, указывающий знак всего числа с плавающей точкой. Порядок и мантисса — целые числа, которые вместе со знаком дают представление числа с плавающей запятой в следующем виде:

<tex>(-1)^S \times M \times B^E</tex>, где <tex>S</tex> {{---}} знак, <tex>B</tex> {{---}} основание, <tex>E</tex> {{---}} порядок, а <tex>M</tex> {{---}} мантисса.
Десятичное число, записываемое как <tex> ReE</tex>, где <tex>R</tex> {{---}} число в полуинтервале <tex>[1; 10)</tex>, <tex>E</tex> {{---}} степень, в которой стоит множитель <tex>10</tex>; в нормализированной форме модуль <tex>R</tex> будет являться мантиссой, а <tex>E</tex> {{---}} порядком, а <tex>S</tex> будет равно <tex>1</tex> тогда и только тогда, когда <tex>R</tex> принимает отрицательное значение.
Например, в числе <tex>-2435e9</tex>
* <tex>S</tex> = <tex>1</tex>
* <tex>B</tex> = <tex>10</tex>
* <tex>M</tex> = <tex>2435</tex>
* <tex>E</tex> = <tex>9</tex>

Порядок также иногда называют '''экспонентой''' или просто '''показателем степени'''.


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

Так же используется формат хранения чисел с фиксированной точкой, который используется для неточных расчётов. Очевидно, что степень числа не хранится в оперативной памяти, а выделяется место для хранения целого числа. Порядок же задаётся программистом.

== Нормальная и нормализованная форма ==

'''Нормальной формой''' (''normal form'') числа с плавающей запятой называется такая форма, в которой мантисса (без учёта знака) в десятичной системе находится на полуинтервале <tex>[0; 1)</tex>. Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, <tex>0,0001</tex> можно записать в 4 формах — <tex>0,0001</tex>×<tex>10</tex><tex>0</tex>, <tex>0,001</tex>×<tex>10</tex><tex>−1</tex>, <tex>0,01</tex>×<tex>10</tex><tex>−2</tex>, <tex>0,1</tex>×<tex>10</tex><tex>−3</tex>), поэтому распространена также другая форма записи — '''нормализованная''' (''normalized''), в которой мантисса десятичного числа принимает значения от <tex>1</tex> (включительно) до <tex>10</tex> (не включительно), а мантисса двоичного числа принимает значения от <tex>1</tex> (включительно) до <tex>2</tex> (не включительно). То есть в мантиссе слева от запятой до применения порядка находится ровно один знак. В такой форме любое число (кроме <tex>0</tex>) записывается единственным образом. Ноль же представить таким образом невозможно, поэтому стандарт предусматривает специальную последовательность битов для задания числа <tex>0</tex> (а заодно и некоторых других [[#Особые значения чисел с плавающей точкой|полезных чисел]], таких как <tex>-\infty</tex> и <tex>+\infty</tex>).
Так как старший двоичный разряд (целая часть) мантиссы вещественного числа в нормализованном виде всегда равен «<tex>1</tex>», то его можно не записывать, сэкономив таким образом один бит, что и используется в стандарте IEEE 754. В позиционных системах счисления с основанием большим, чем <tex>2</tex> (в троичной, четверичной и др.), этого замечательного свойства нет (ведь целая часть там может быть не только единицей).

== Типы чисел с плавающей точкой (по IEEE 754) ==
=== Число половинной точности (''Binary16'', ''Half precision'') ===

'''Число́ полови́нной то́чности''' — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — <tex>16</tex> бит или <tex>2</tex> байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=3 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=2 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=6 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|со сдвигом]] '''<tex>-15</tex>'''. То есть чтобы получить актуально значение порядка нужно вычесть из него сдвиг. Сдвиг можно получить по формуле <tex>2^{b-1}-1</tex>, где <tex>b</tex> {{---}} число бит, отведенное на хранение порядка (в случае числа половинной точности <tex>b=5</tex>).

'''Ограничения точности'''
* Целые от нуля до <tex>2048</tex> передаются как есть.
* Целые от <tex>2049</tex> до <tex>4096</tex> округляются к ближайшему чётному целому.
* Целые от <tex>4097</tex> до <tex>8192</tex> округляются до ближайшего целого, делящегося нацело на четыре.
* Целые от <tex>8193</tex> до <tex>16384</tex> округляются до ближайшего целого, делящегося на восемь.
* Целые от <tex>16385</tex> до <tex>32768</tex> округляются до ближайшего целого, делящегося на шестнадцать.
* Целые от <tex>32769</tex> до <tex>65535</tex> округляются до ближайшего целого, делящегося на тридцать два.

=== Число одинарной точности (''Binary32'', ''Single precision'', ''float'') ===

'''Число́ одина́рной то́чности''' — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — <tex>32</tex> бита или <tex>4</tex> байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.

{|class="wikitable" style="background-color: transparent; border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=8 style="background-color: lightgreen; border: thin solid black"|Порядок (8 бит)
!colspan=24 style="background-color: lightcoral; border: thin solid black"|Мантисса (23+1 бита)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"|
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|30
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|23
|style="border: none"|
|colspan=20 style="border: none; border-left: 1px solid gray; text-align: left"|22
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-127</tex>'''.

=== Число двойной точности (''Binary64'', ''Double precision'', ''double'') ===

'''Число́ двойно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — <tex>64</tex> бита или <tex>8</tex> байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=11 style="background-color: lightgreen; border: thin solid black"|Порядок (11 бит)
!colspan=53 style="background-color: lightcoral; border: thin solid black"|Мантисса (52+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|62
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|52
|style="border: none"|
|colspan=48 style="border: none; border-left: 1px solid gray; text-align: left"|51
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-1023</tex>'''.

=== Число четверной точности (''Binary128'', ''Quadruple precision'') ===

'''Число́ четверно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — <tex>128</tex> бит или <tex>16</tex> байт). Используется в случае необходимости крайне высокой точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=15 style="background-color: lightgreen; border: thin solid black"|Порядок (15 бит)
!colspan=47 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=8 style="border: none; border-left: 1px solid gray; text-align: left"|126
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|112
|style="border: none"|
|colspan=38 style="border: none; border-left: 1px solid gray; text-align: left"|111
|}
 
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=66 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|colspan=66 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-16383</tex>'''.

Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки. Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью).
В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.

=== Диапазон значений чисел с плавающей запятой ===
Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, "не число", получается как результат операций типа деления нуля на ноль) и <tex>\pm\infty</tex>.

Данная таблица только лишь примерно указывает границы допустимых значений, без учета возрастающей погрешности с ростом абсолютного значения и существования [[#Денормализованные числа|денормализованных чисел]].


{| class="wikitable"
!Название в IEEE 754|| Название типа переменной в Си || Диапазон значений || Бит в мантиссе || Бит на переменную
|-
|Half precision||-||6,10×10-5..65504||11||16
|-
|Single presicion||float||3,4×10-38..3,4×1038||23||32
|-
|Double precision||double||1,7×10-308..1,7×10308||53||64
|-
|Extended precision||На некоторых архитектурах (например в сопроцессоре Intel) long double||3,4×10-4932..3,4×104932||65||80
|}

== Особые значения чисел с плавающей точкой ==
=== Ноль (со знаком) ===
Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль. Поэтому для его представления зарезервированы специальные значения мантиссы и порядка {{---}} число считается нулём, если все его биты, кроме знакового, равны нулю. При этом в зависимости от значения бита знака ноль может быть как положительным, так и отрицательным.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm0</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

'''Арифметика нуля со знаком'''
 
Арифметика отрицательного нуля аналогична таковой для любого отрицательного числа и понятна интуитивно. Вот несколько примеров:

* <tex>\frac{-0}{ \left| x \right| } = -0\,\!</tex> (если <tex>x\ne0</tex>)

* <tex>(-0) \cdot (-0) = +0\,\!</tex>

* <tex>\left| x \right| \cdot (-0) = -0\,\!</tex>

* <tex>x + (\pm 0) = x\,\!</tex>

* <tex>(-0) + (-0) = -0\,\!</tex>

* <tex>(+0) + (+0) = +0\,\!</tex>

* <tex>\frac{-0}{-\infty} = +0\,\!</tex>

* <tex>\frac{\left|x\right|}{-0} = -\infty\,\!</tex> (если <tex>x\ne0</tex>)

=== Неопределенность (''NaN'') ===
'''NaN''' {{---}} это аббревиатура от фразы "''not a number''". NaN является результатом арифметических операций, если во время их выполнения произошла ошибка (примеры см. ниже). В IEEE 754 NaN представлен как число, в котором все двоичные разряды порядка {{---}} единицы, а мантисса не нулевая.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: transparent; border: none"| = <tex>NaN</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.

'''Как можно получить NaN?'''
 

* <tex>\infty+(-\infty)= NaN</tex>

* <tex>0\times\infty= NaN</tex>

* <tex>\frac{\pm0}{\pm0}=\frac{\pm\infty}{\pm\infty} = NaN</tex>

* <tex>\sqrt{x} = NaN</tex>, где <tex>x<0</tex>

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

По определению NaN ≠ NaN, поэтому, для проверки значения переменной нужно просто сравнить ее с собой.


=== Бесконечности ===
В число с плавающей запятой можно записать значение <tex>+\infty</tex> или <tex>-\infty</tex>. Как и нули со знаком, бесконечности позволяют получить хотя бы близкий к правильному результат вычисления в случае переполнения. Согласно стандарту IEEE 754 число с плавающей запятой считается равным бесконечности, если все двоичные разряды его порядка {{---}} единицы, а мантисса равна нулю. Знак бесконечности определяется знаковым битом числа.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm\infty</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Получить бесконечность можно при переполнении и при делении ненулевого числа на ноль. При этом
<tex dpi = "180">
\frac{x}{0}
</tex>
<tex>=
\begin{cases}
+\infty,&\text{если $x>0$;}\\
NaN,&\text{если $x=0$;}\\
-\infty,&\text{если $x<0$.}
\end{cases}

</tex>

=== Денормализованные числа ===
'''Денормализованные числа''' (''denormalized/subnormal numbers'') - это способ увеличить количество представимых числом с плавающей запятой значений около нуля, дабы повысить точность вычислений. Каждое значение денормализованного числа меньше самого маленького '''нормализованного''' ("обычного") значения числа с плавающей запятой.
Согласно стандарту, если порядок равен своему минимальному значению (все его биты {{---}} нули, а истинное значение порядка равно его сдвигу) и все биты мантиссы равны нулю, то это <tex>\pm0</tex>. Если же мантисса не равна нулю, то это число с порядком, на единицу большим минимального (все биты порядка, кроме младшего {{---}} нули) и данной мантиссой, '''целая часть которой считается равной нулю, а не единице'''.

То есть число с плавающей запятой, при учете вышесказанного, можно задать следующим образом:
 
* <tex>(-1)^s\times1.M\times2^E</tex>, если <tex>E_{min} \le E \le E_{max}</tex> (''нормализованное число'')

* <tex>(-1)^s\times0.M\times2^{E_{min}}</tex>, если <tex>E=E_{min}-1</tex> (''денормализованное число'')

Где <tex>s</tex> {{---}} бит знака, <tex>M</tex> {{---}} последовательность битов мантиссы, <tex>E</tex> {{---}} значение порядка (с учетом сдвига), <tex>E_{min}</tex> {{---}} минимальное значение порядка, используемое для записи чисел (1 {{---}} ''сдвиг'') , <tex>E_{min}-1</tex> {{---}} минимальное значение порядка, которое он в принципе может принять (все биты нули, 0 {{---}} ''сдвиг'').

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

В современных процессорах обработка денормализованных чисел происходит в десятки раз медленнее, чем обработка нормализованных чисел. Ниже приведена часть таблицы из статьи Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values"<ref>[http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf Статья Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values" ''(англ.)'']</ref>

{| class="wikitable"
!Производитель||Процессор||Замедление (разы)
|-
|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-х разрядном формате <tex>-269</tex> <tex>7</tex>/<tex>32</tex> и <tex>405,875</tex>.
Переведем <tex>-269</tex> <tex>7</tex>/<tex>32</tex> в машинный вид. Для этого сначала переведем его в двоичную систему счисления.
<tex>-269</tex> <tex>7</tex>/<tex>32</tex> = <tex>-269,21875</tex>
<tex>-269,21875</tex><tex>10</tex> = <tex>-100001101,00111</tex><tex>2</tex>

Нормализуем полученное двоичное число по правилам машинной арифметики.
<tex>-100001101{,}00111</tex> = <tex>-1{,}0000110100111</tex> × <tex>10</tex><tex>1000</tex>

Найдем смещенный порядок. Так как в условии говорится о 32-разрядном представлении, то смещение порядка равно <tex>127</tex><tex>10</tex>.
E = <tex>8</tex><tex>10</tex> + <tex>127</tex><tex>10</tex> = <tex>1000</tex><tex>2</tex> + <tex>1111111</tex><tex>2</tex> = <tex>10000111</tex><tex>2</tex>

Число отрицательное, следовательно, в бите знака будет стоять единица.

Итак, первое число в машинном 32-разрядном представлении с плавающей точкой будет иметь вид:
<tex>1</tex>10000111<tex>00001101001110000000000</tex> (жирным шрифтом выделен порядок числа, длина мантиссы {{---}} 23 бита).

Переведем второе число в машинный вид, совершая те же действия.

<tex>405,87510</tex> = <tex>110010101</tex>,<tex>111000000000011010</tex>...<tex>2</tex> = <tex>1,10010101111000000000011010</tex>... × <tex>10</tex><tex>1000</tex>
В качестве мантиссы будут сохранены первые <tex>23</tex> бита после запятой т.е. <tex>10010101111000000000011</tex>.
Очевидно, что порядок со смещением у второго числа будет таким же, как и у первого.

Второе число положительное, следовательно, бит знака будет содержать ноль.

Итак в машинном 32-разрядном представлении второе число будет иметь вид:

<tex>0</tex>10000111<tex>10010101111000000000011</tex>
Далее в арифметических операциях будет использоваться число <tex>110010101</tex>,<tex>111</tex><tex>2</tex>=<tex>405</tex>.<tex>875</tex><tex>10</tex>, а не <tex>110010101</tex>,<tex>111000000000011</tex><tex>2</tex>=<tex>405</tex>,<tex>87510</tex><tex>10</tex> видимо для упрощения(хотя это не совсем корректно).

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

<tex>1</tex>,<tex>1001010111100</tex><tex>2</tex> - <tex>1</tex>,<tex>0000110100111</tex><tex>2</tex> = <tex>0</tex>,<tex>1000100010101</tex><tex>2</tex>

Приводим полученный результат к машинному виду. Для этого мы должны внести поправку в порядок {{---}} уменьшить его на единицу.
Знак результата {{---}} положительный, следовательно, бит знака содержит ноль.

<tex>0</tex>10000110<tex>00010001010100000000000</tex>

Проверим правильность наших вычислений. Переведем результат в десятичное представление.

Найдем реальный порядок результата, вычтя из него значение смещения <tex>127</tex><tex>10</tex>.

E = <tex>10000110</tex><tex>2</tex> - <tex>1111111</tex><tex>2</tex> = <tex>134</tex><tex>10</tex> - <tex>127</tex><tex>10</tex> = <tex>7</tex><tex>10</tex> = <tex>111</tex><tex>2</tex>

Следовательно, число результата будет иметь вид:
A = <tex>1</tex>,<tex>000100010101</tex> × <tex>10</tex><tex>111</tex> = <tex>10001000</tex>,<tex>10101</tex><tex>2</tex> = <tex>136</tex>,<tex>65625</tex><tex>10</tex>

Результат наших вычислений верен, так как <tex>405</tex>,<tex>875</tex> - <tex>269</tex>,<tex>21875</tex> = <tex>136</tex>,<tex>65625</tex>.

=== Алгоритм получения представления вещественного числа в памяти ЭВМ ===

Покажем преобразование действительного числа для представления его в

памяти ЭВМ на примере величины типа Double.

Как видно из таблицы, величина этого типа занимает в памяти <tex>8</tex> байт. На

рисунке ниже показано, как здесь представлены поля мантиссы и порядка (нумерация битов осуществляется справа налево):

{|class="wikitable"
!Знак || Смещённый порядок || Мантисса
|-
|63 || 62..52 || 51..0
|}

Можно заметить, что старший бит, отведенный под мантиссу, имеет номер

<tex>51</tex>, т.е. мантисса занимает младшие <tex>52</tex> бита. Черта указывает здесь на

положение двоичной запятой. Перед запятой должен стоять бит целой части

мантиссы, но поскольку она всегда равна <tex>1</tex>, здесь данный бит не требуется и

соответствующий разряд отсутствует в памяти (но он подразумевается).

Значение порядка хранится здесь не как целое число, представленное в

дополнительном коде. Для упрощения вычислений и сравнения действительных

чисел значение порядка в ЭВМ хранится в виде смещенного числа, т.е. к

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

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

соответствовал нуль. Например, для типа Double порядок занимает <tex>11</tex> бит и

имеет диапазон от <tex>2</tex><tex>-1023</tex> до <tex>2</tex><tex>1023</tex>, поэтому смещение равно <tex>1023</tex>(<tex>10</tex>) =

<tex>1111111111</tex>(<tex>2</tex>). Наконец, бит с номером <tex>63</tex> указывает на знак числа.

Таким образом, из вышесказанного вытекает следующий алгоритм для

получения представления действительного числа в памяти ЭВМ:

<OL>

<LI>перевести модуль данного числа в двоичную систему счисления;</LI>

<LI>нормализовать двоичное число, т.е. записать в виде M × 2p, где M 

мантисса (ее целая часть равна <tex>1</tex>(<tex>2</tex>)) и p  порядок, записанный в

десятичной системе счисления;</LI>

<LI>прибавить к порядку смещение и перевести смещенный порядок в двоичную

систему счисления;</LI>

<LI>учитывая знак заданного числа (0  положительное; 1  отрицательное),

выписать его представление в памяти ЭВМ.</LI>

</OL>

Пример. Запишем код числа <tex>-312</tex>,<tex>3125</tex>.

<OL>

<LI>Двоичная запись модуля этого числа имеет вид <tex>100111000</tex>,<tex>0101</tex>.</LI>

<LI>Имеем <tex>100111000</tex>,<tex>0101</tex> =

<tex>1</tex>,<tex>001110000101</tex> × <tex>2</tex><tex>8</tex>.</LI>

<LI>Получаем смещенный порядок <tex>8</tex> + <tex>1023</tex> = <tex>1031</tex>. Далее имеем

<tex>1031</tex>(<tex>10</tex>) = <tex>10000000111</tex>(<tex>2</tex>).</LI>

<LI>Окончательно

{|class="wikitable"
| 1 || 10000000111 || 0011100001010000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

</LI>

</OL>

Очевидно, что более компактно полученный код стоит записать следующим

образом: C073850000000000(16).

Другой пример иллюстрирует обратный переход от кода действительного

числа к самому числу.

Пример. Пусть дан код 3FEC600000000000(16) или

<OL>

{|class="wikitable"
| 0 || 01111111110 || 1100011000000000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

<LI>Прежде всего замечаем, что это код положительного числа, поскольку в

разряде с номером <tex>63</tex> записан нуль. Получим порядок этого числа:

<tex>01111111110</tex>(<tex>2</tex>) = <tex>1022</tex>(<tex>10</tex>); <tex>1022</tex> - <tex>1023</tex> = <tex>-1</tex>.</LI>

<LI>Число имеет вид <tex>1</tex>,<tex>1100011</tex> × <tex>2</tex><tex>-1</tex> или

<tex>0</tex>,<tex>11100011</tex>.</LI>

<LI>Переводом в десятичную систему счисления получаем <tex>0</tex>,<tex>88671875</tex>.</LI>

</OL>

== См. также ==
* [[Представление символов, таблицы кодировок]]
* [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]

== Примечания ==
<references/>

== Ссылки ==
=== Использованные материалы ===
'''На русском'''
* [http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C Википедия {{---}} Экспоненциальная запись]
* [http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D0%B7%D0%B0%D0%BF%D1%8F%D1%82%D0%BE%D0%B9 Википедия {{---}} Число с плавающей запятой]
* [http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%80%D0%B8%D1%86%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BD%D0%BE%D0%BB%D1%8C Википедия {{---}} Отрицательный и положительный ноль]
*[http://habrahabr.ru/blogs/cpp/112953/ Хабрахабр {{---}} статья пользователя Yruslan "Что нужно знать про арифметику с плавающей запятой"]
*[http://www.sgu.ru/prcnit/teach/3.php Статья Лапшевой Е.Е. "Машинная арифметика с вещественными числами"]

'''На английском'''
*[http://en.wikipedia.org/wiki/NaN Wikipedia {{---}} NaN]
*[http://en.wikipedia.org/wiki/Floating_point Wikipedia {{---}} Floating point]
*[http://en.wikipedia.org/wiki/IEEE_754-2008 Wikipedia {{---}} IEEE 754-2008]

=== Что стоит прочесть ===
* [http://grouper.ieee.org/groups/754 Материалы по стандарту IEEE 754 ''(англ.)'']
* [http://softelectro.ru/ieee754.html Русский перевод стандарта IEEE 754]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Представление информации]]

Представление вещественных чисел

2015-01-12T17:59:18Z

Паршуков Кирилл:

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

Число с плавающей запятой состоит из набора отдельных двоичных разрядов, условно разделенных на так называемые '''знак''' (''sign''), '''порядок''' (''exponent'') и '''мантиссу''' (''mantis''). В наиболее распространённом формате (стандарт IEEE 754) число с плавающей запятой представляется в виде набора битов, часть из которых кодирует собой мантиссу числа, другая часть — показатель степени, и ещё один бит используется для указания знака числа (<tex>0</tex> {{---}} если число положительное, <tex>1</tex> {{---}} если число отрицательное). При этом порядок записывается как целое число в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|коде со сдвигом]], а мантисса {{---}} в [[#Нормальная и нормализованная форма|нормализованном виде]], своей дробной частью в двоичной системе счисления. Вот пример такого числа из <tex>16</tex> двоичных разрядов:
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=10 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0

!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Знак {{---}} один бит, указывающий знак всего числа с плавающей точкой. Порядок и мантисса — целые числа, которые вместе со знаком дают представление числа с плавающей запятой в следующем виде:

<tex>(-1)^S \times M \times B^E</tex>, где <tex>S</tex> {{---}} знак, <tex>B</tex> {{---}} основание, <tex>E</tex> {{---}} порядок, а <tex>M</tex> {{---}} мантисса.
Десятичное число, записываемое как <tex> ReE</tex>, где <tex>R</tex> {{---}} число в полуинтервале <tex>[1; 10)</tex>, <tex>E</tex> {{---}} степень, в которой стоит множитель <tex>10</tex>; в нормализированной форме модуль <tex>R</tex> будет являться мантиссой, а <tex>E</tex> {{---}} порядком, а <tex>S</tex> будет равно <tex>1</tex> тогда и только тогда, когда <tex>R</tex> принимает отрицательное значение.
Например, в числе <tex>-2435e9</tex>
* <tex>S</tex> = <tex>1</tex>
* <tex>B</tex> = <tex>10</tex>
* <tex>M</tex> = <tex>2435</tex>
* <tex>E</tex> = <tex>9</tex>

Порядок также иногда называют '''экспонентой''' или просто '''показателем степени'''.


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

Так же используется формат хранения чисел с фиксированной точкой, который используется для неточных расчётов. Очевидно, что степень числа не хранится в оперативной памяти, а выделяется место для хранения целого числа. Порядок же задаётся программистом.

== Нормальная и нормализованная форма ==

'''Нормальной формой''' (''normal form'') числа с плавающей запятой называется такая форма, в которой мантисса (без учёта знака) в десятичной системе находится на полуинтервале <tex>[0; 1)</tex>. Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, <tex>0,0001</tex> можно записать в 4 формах — <tex>0,0001</tex>×<tex>10</tex><tex>0</tex>, <tex>0,001</tex>×<tex>10</tex><tex>−1</tex>, <tex>0,01</tex>×<tex>10</tex><tex>−2</tex>, <tex>0,1</tex>×<tex>10</tex><tex>−3</tex>), поэтому распространена также другая форма записи — '''нормализованная''' (''normalized''), в которой мантисса десятичного числа принимает значения от <tex>1</tex> (включительно) до <tex>10</tex> (не включительно), а мантисса двоичного числа принимает значения от <tex>1</tex> (включительно) до <tex>2</tex> (не включительно). То есть в мантиссе слева от запятой до применения порядка находится ровно один знак. В такой форме любое число (кроме <tex>0</tex>) записывается единственным образом. Ноль же представить таким образом невозможно, поэтому стандарт предусматривает специальную последовательность битов для задания числа <tex>0</tex> (а заодно и некоторых других [[#Особые значения чисел с плавающей точкой|полезных чисел]], таких как <tex>-\infty</tex> и <tex>+\infty</tex>).
Так как старший двоичный разряд (целая часть) мантиссы вещественного числа в нормализованном виде всегда равен «<tex>1</tex>», то его можно не записывать, сэкономив таким образом один бит, что и используется в стандарте IEEE 754. В позиционных системах счисления с основанием большим, чем <tex>2</tex> (в троичной, четверичной и др.), этого замечательного свойства нет (ведь целая часть там может быть не только единицей).

== Типы чисел с плавающей точкой (по IEEE 754) ==
=== Число половинной точности (''Binary16'', ''Half precision'') ===

'''Число́ полови́нной то́чности''' — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — <tex>16</tex> бит или <tex>2</tex> байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=3 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=2 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=6 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|со сдвигом]] '''<tex>-15</tex>'''. То есть чтобы получить актуально значение порядка нужно вычесть из него сдвиг. Сдвиг можно получить по формуле <tex>2^{b-1}-1</tex>, где <tex>b</tex> {{---}} число бит, отведенное на хранение порядка (в случае числа половинной точности <tex>b=5</tex>).

'''Ограничения точности'''
* Целые от нуля до <tex>2048</tex> передаются как есть.
* Целые от <tex>2049</tex> до <tex>4096</tex> округляются к ближайшему чётному целому.
* Целые от <tex>4097</tex> до <tex>8192</tex> округляются до ближайшего целого, делящегося нацело на четыре.
* Целые от <tex>8193</tex> до <tex>16384</tex> округляются до ближайшего целого, делящегося на восемь.
* Целые от <tex>16385</tex> до <tex>32768</tex> округляются до ближайшего целого, делящегося на шестнадцать.
* Целые от <tex>32769</tex> до <tex>65535</tex> округляются до ближайшего целого, делящегося на тридцать два.

=== Число одинарной точности (''Binary32'', ''Single precision'', ''float'') ===

'''Число́ одина́рной то́чности''' — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — <tex>32</tex> бита или <tex>4</tex> байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.

{|class="wikitable" style="background-color: transparent; border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=8 style="background-color: lightgreen; border: thin solid black"|Порядок (8 бит)
!colspan=24 style="background-color: lightcoral; border: thin solid black"|Мантисса (23+1 бита)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"|
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|30
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|23
|style="border: none"|
|colspan=20 style="border: none; border-left: 1px solid gray; text-align: left"|22
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-127</tex>'''.

=== Число двойной точности (''Binary64'', ''Double precision'', ''double'') ===

'''Число́ двойно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — <tex>64</tex> бита или <tex>8</tex> байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=11 style="background-color: lightgreen; border: thin solid black"|Порядок (11 бит)
!colspan=53 style="background-color: lightcoral; border: thin solid black"|Мантисса (52+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|62
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|52
|style="border: none"|
|colspan=48 style="border: none; border-left: 1px solid gray; text-align: left"|51
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-1023</tex>'''.

=== Число четверной точности (''Binary128'', ''Quadruple precision'') ===

'''Число́ четверно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — <tex>128</tex> бит или <tex>16</tex> байт). Используется в случае необходимости крайне высокой точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=15 style="background-color: lightgreen; border: thin solid black"|Порядок (15 бит)
!colspan=47 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=8 style="border: none; border-left: 1px solid gray; text-align: left"|126
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|112
|style="border: none"|
|colspan=38 style="border: none; border-left: 1px solid gray; text-align: left"|111
|}
 
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=66 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|colspan=66 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-16383</tex>'''.

Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки (но присутствует в процессоре Intel). Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью).
В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.

=== Диапазон значений чисел с плавающей запятой ===
Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, "не число", получается как результат операций типа деления нуля на ноль) и <tex>\pm\infty</tex>.

Данная таблица только лишь примерно указывает границы допустимых значений, без учета возрастающей погрешности с ростом абсолютного значения и существования [[#Денормализованные числа|денормализованных чисел]].


{| class="wikitable"
!Название в IEEE 754|| Название типа переменной в Си || Диапазон значений || Бит в мантиссе || Бит на переменную
|-
|Half precision||-||6,10×10-5..65504||11||16
|-
|Single presicion||float||3,4×10-38..3,4×1038||23||32
|-
|Double precision||double||1,7×10-308..1,7×10308||53||64
|-
|Extended precision||На некоторых архитектурах long double||3,4×10-4932..3,4×104932||65||80
|}

== Особые значения чисел с плавающей точкой ==
=== Ноль (со знаком) ===
Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль. Поэтому для его представления зарезервированы специальные значения мантиссы и порядка {{---}} число считается нулём, если все его биты, кроме знакового, равны нулю. При этом в зависимости от значения бита знака ноль может быть как положительным, так и отрицательным.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm0</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

'''Арифметика нуля со знаком'''
 
Арифметика отрицательного нуля аналогична таковой для любого отрицательного числа и понятна интуитивно. Вот несколько примеров:

* <tex>\frac{-0}{ \left| x \right| } = -0\,\!</tex> (если <tex>x\ne0</tex>)

* <tex>(-0) \cdot (-0) = +0\,\!</tex>

* <tex>\left| x \right| \cdot (-0) = -0\,\!</tex>

* <tex>x + (\pm 0) = x\,\!</tex>

* <tex>(-0) + (-0) = -0\,\!</tex>

* <tex>(+0) + (+0) = +0\,\!</tex>

* <tex>\frac{-0}{-\infty} = +0\,\!</tex>

* <tex>\frac{\left|x\right|}{-0} = -\infty\,\!</tex> (если <tex>x\ne0</tex>)

=== Неопределенность (''NaN'') ===
'''NaN''' {{---}} это аббревиатура от фразы "''not a number''". NaN является результатом арифметических операций, если во время их выполнения произошла ошибка (примеры см. ниже). В IEEE 754 NaN представлен как число, в котором все двоичные разряды порядка {{---}} единицы, а мантисса не нулевая.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: transparent; border: none"| = <tex>NaN</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.

'''Как можно получить NaN?'''
 

* <tex>\infty+(-\infty)= NaN</tex>

* <tex>0\times\infty= NaN</tex>

* <tex>\frac{\pm0}{\pm0}=\frac{\pm\infty}{\pm\infty} = NaN</tex>

* <tex>\sqrt{x} = NaN</tex>, где <tex>x<0</tex>

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

По определению NaN ≠ NaN, поэтому, для проверки значения переменной нужно просто сравнить ее с собой.


=== Бесконечности ===
В число с плавающей запятой можно записать значение <tex>+\infty</tex> или <tex>-\infty</tex>. Как и нули со знаком, бесконечности позволяют получить хотя бы близкий к правильному результат вычисления в случае переполнения. Согласно стандарту IEEE 754 число с плавающей запятой считается равным бесконечности, если все двоичные разряды его порядка {{---}} единицы, а мантисса равна нулю. Знак бесконечности определяется знаковым битом числа.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm\infty</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Получить бесконечность можно при переполнении и при делении ненулевого числа на ноль. При этом
<tex dpi = "180">
\frac{x}{0}
</tex>
<tex>=
\begin{cases}
+\infty,&\text{если $x>0$;}\\
NaN,&\text{если $x=0$;}\\
-\infty,&\text{если $x<0$.}
\end{cases}

</tex>

=== Денормализованные числа ===
'''Денормализованные числа''' (''denormalized/subnormal numbers'') - это способ увеличить количество представимых числом с плавающей запятой значений около нуля, дабы повысить точность вычислений. Каждое значение денормализованного числа меньше самого маленького '''нормализованного''' ("обычного") значения числа с плавающей запятой.
Согласно стандарту, если порядок равен своему минимальному значению (все его биты {{---}} нули, а истинное значение порядка равно его сдвигу) и все биты мантиссы равны нулю, то это <tex>\pm0</tex>. Если же мантисса не равна нулю, то это число с порядком, на единицу большим минимального (все биты порядка, кроме младшего {{---}} нули) и данной мантиссой, '''целая часть которой считается равной нулю, а не единице'''.

То есть число с плавающей запятой, при учете вышесказанного, можно задать следующим образом:
 
* <tex>(-1)^s\times1.M\times2^E</tex>, если <tex>E_{min} \le E \le E_{max}</tex> (''нормализованное число'')

* <tex>(-1)^s\times0.M\times2^{E_{min}}</tex>, если <tex>E=E_{min}-1</tex> (''денормализованное число'')

Где <tex>s</tex> {{---}} бит знака, <tex>M</tex> {{---}} последовательность битов мантиссы, <tex>E</tex> {{---}} значение порядка (с учетом сдвига), <tex>E_{min}</tex> {{---}} минимальное значение порядка, используемое для записи чисел (1 {{---}} ''сдвиг'') , <tex>E_{min}-1</tex> {{---}} минимальное значение порядка, которое он в принципе может принять (все биты нули, 0 {{---}} ''сдвиг'').

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

В современных процессорах обработка денормализованных чисел происходит в десятки раз медленнее, чем обработка нормализованных чисел. Ниже приведена часть таблицы из статьи Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values"<ref>[http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf Статья Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values" ''(англ.)'']</ref>

{| class="wikitable"
!Производитель||Процессор||Замедление (разы)
|-
|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-х разрядном формате <tex>-269</tex> <tex>7</tex>/<tex>32</tex> и <tex>405,875</tex>.
Переведем <tex>-269</tex> <tex>7</tex>/<tex>32</tex> в машинный вид. Для этого сначала переведем его в двоичную систему счисления.
<tex>-269</tex> <tex>7</tex>/<tex>32</tex> = <tex>-269,21875</tex>
<tex>-269,21875</tex><tex>10</tex> = <tex>-100001101,00111</tex><tex>2</tex>

Нормализуем полученное двоичное число по правилам машинной арифметики.
<tex>-100001101{,}00111</tex> = <tex>-1{,}0000110100111</tex> × <tex>10</tex><tex>1000</tex>

Найдем смещенный порядок. Так как в условии говорится о 32-разрядном представлении, то смещение порядка равно <tex>127</tex><tex>10</tex>.
E = <tex>8</tex><tex>10</tex> + <tex>127</tex><tex>10</tex> = <tex>1000</tex><tex>2</tex> + <tex>1111111</tex><tex>2</tex> = <tex>10000111</tex><tex>2</tex>

Число отрицательное, следовательно, в бите знака будет стоять единица.

Итак, первое число в машинном 32-разрядном представлении с плавающей точкой будет иметь вид:
<tex>1</tex>10000111<tex>00001101001110000000000</tex> (жирным шрифтом выделен порядок числа, длина мантиссы {{---}} 23 бита).

Переведем второе число в машинный вид, совершая те же действия.

<tex>405,87510</tex> = <tex>110010101</tex>,<tex>111000000000011010</tex>...<tex>2</tex> = <tex>1,10010101111000000000011010</tex>... × <tex>10</tex><tex>1000</tex>
В качестве мантиссы будут сохранены первые <tex>23</tex> бита после запятой т.е. <tex>10010101111000000000011</tex>.
Очевидно, что порядок со смещением у второго числа будет таким же, как и у первого.

Второе число положительное, следовательно, бит знака будет содержать ноль.

Итак в машинном 32-разрядном представлении второе число будет иметь вид:

<tex>0</tex>10000111<tex>10010101111000000000011</tex>
Далее в арифметических операциях будет использоваться число <tex>110010101</tex>,<tex>111</tex><tex>2</tex>=<tex>405</tex>.<tex>875</tex><tex>10</tex>, а не <tex>110010101</tex>,<tex>111000000000011</tex><tex>2</tex>=<tex>405</tex>,<tex>87510</tex><tex>10</tex> видимо для упрощения(хотя это не совсем корректно).

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

<tex>1</tex>,<tex>1001010111100</tex><tex>2</tex> - <tex>1</tex>,<tex>0000110100111</tex><tex>2</tex> = <tex>0</tex>,<tex>1000100010101</tex><tex>2</tex>

Приводим полученный результат к машинному виду. Для этого мы должны внести поправку в порядок {{---}} уменьшить его на единицу.
Знак результата {{---}} положительный, следовательно, бит знака содержит ноль.

<tex>0</tex>10000110<tex>00010001010100000000000</tex>

Проверим правильность наших вычислений. Переведем результат в десятичное представление.

Найдем реальный порядок результата, вычтя из него значение смещения <tex>127</tex><tex>10</tex>.

E = <tex>10000110</tex><tex>2</tex> - <tex>1111111</tex><tex>2</tex> = <tex>134</tex><tex>10</tex> - <tex>127</tex><tex>10</tex> = <tex>7</tex><tex>10</tex> = <tex>111</tex><tex>2</tex>

Следовательно, число результата будет иметь вид:
A = <tex>1</tex>,<tex>000100010101</tex> × <tex>10</tex><tex>111</tex> = <tex>10001000</tex>,<tex>10101</tex><tex>2</tex> = <tex>136</tex>,<tex>65625</tex><tex>10</tex>

Результат наших вычислений верен, так как <tex>405</tex>,<tex>875</tex> - <tex>269</tex>,<tex>21875</tex> = <tex>136</tex>,<tex>65625</tex>.

=== Алгоритм получения представления вещественного числа в памяти ЭВМ ===

Покажем преобразование действительного числа для представления его в

памяти ЭВМ на примере величины типа Double.

Как видно из таблицы, величина этого типа занимает в памяти <tex>8</tex> байт. На

рисунке ниже показано, как здесь представлены поля мантиссы и порядка (нумерация битов осуществляется справа налево):

{|class="wikitable"
!Знак || Смещённый порядок || Мантисса
|-
|63 || 62..52 || 51..0
|}

Можно заметить, что старший бит, отведенный под мантиссу, имеет номер

<tex>51</tex>, т.е. мантисса занимает младшие <tex>52</tex> бита. Черта указывает здесь на

положение двоичной запятой. Перед запятой должен стоять бит целой части

мантиссы, но поскольку она всегда равна <tex>1</tex>, здесь данный бит не требуется и

соответствующий разряд отсутствует в памяти (но он подразумевается).

Значение порядка хранится здесь не как целое число, представленное в

дополнительном коде. Для упрощения вычислений и сравнения действительных

чисел значение порядка в ЭВМ хранится в виде смещенного числа, т.е. к

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

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

соответствовал нуль. Например, для типа Double порядок занимает <tex>11</tex> бит и

имеет диапазон от <tex>2</tex><tex>-1023</tex> до <tex>2</tex><tex>1023</tex>, поэтому смещение равно <tex>1023</tex>(<tex>10</tex>) =

<tex>1111111111</tex>(<tex>2</tex>). Наконец, бит с номером <tex>63</tex> указывает на знак числа.

Таким образом, из вышесказанного вытекает следующий алгоритм для

получения представления действительного числа в памяти ЭВМ:

<OL>

<LI>перевести модуль данного числа в двоичную систему счисления;</LI>

<LI>нормализовать двоичное число, т.е. записать в виде M × 2p, где M 

мантисса (ее целая часть равна <tex>1</tex>(<tex>2</tex>)) и p  порядок, записанный в

десятичной системе счисления;</LI>

<LI>прибавить к порядку смещение и перевести смещенный порядок в двоичную

систему счисления;</LI>

<LI>учитывая знак заданного числа (0  положительное; 1  отрицательное),

выписать его представление в памяти ЭВМ.</LI>

</OL>

Пример. Запишем код числа <tex>-312</tex>,<tex>3125</tex>.

<OL>

<LI>Двоичная запись модуля этого числа имеет вид <tex>100111000</tex>,<tex>0101</tex>.</LI>

<LI>Имеем <tex>100111000</tex>,<tex>0101</tex> =

<tex>1</tex>,<tex>001110000101</tex> × <tex>2</tex><tex>8</tex>.</LI>

<LI>Получаем смещенный порядок <tex>8</tex> + <tex>1023</tex> = <tex>1031</tex>. Далее имеем

<tex>1031</tex>(<tex>10</tex>) = <tex>10000000111</tex>(<tex>2</tex>).</LI>

<LI>Окончательно

{|class="wikitable"
| 1 || 10000000111 || 0011100001010000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

</LI>

</OL>

Очевидно, что более компактно полученный код стоит записать следующим

образом: C073850000000000(16).

Другой пример иллюстрирует обратный переход от кода действительного

числа к самому числу.

Пример. Пусть дан код 3FEC600000000000(16) или

<OL>

{|class="wikitable"
| 0 || 01111111110 || 1100011000000000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

<LI>Прежде всего замечаем, что это код положительного числа, поскольку в

разряде с номером <tex>63</tex> записан нуль. Получим порядок этого числа:

<tex>01111111110</tex>(<tex>2</tex>) = <tex>1022</tex>(<tex>10</tex>); <tex>1022</tex> - <tex>1023</tex> = <tex>-1</tex>.</LI>

<LI>Число имеет вид <tex>1</tex>,<tex>1100011</tex> × <tex>2</tex><tex>-1</tex> или

<tex>0</tex>,<tex>11100011</tex>.</LI>

<LI>Переводом в десятичную систему счисления получаем <tex>0</tex>,<tex>88671875</tex>.</LI>

</OL>

== См. также ==
* [[Представление символов, таблицы кодировок]]
* [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]

== Примечания ==
<references/>

== Ссылки ==
=== Использованные материалы ===
'''На русском'''
* [http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C Википедия {{---}} Экспоненциальная запись]
* [http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D0%B7%D0%B0%D0%BF%D1%8F%D1%82%D0%BE%D0%B9 Википедия {{---}} Число с плавающей запятой]
* [http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%80%D0%B8%D1%86%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BD%D0%BE%D0%BB%D1%8C Википедия {{---}} Отрицательный и положительный ноль]
*[http://habrahabr.ru/blogs/cpp/112953/ Хабрахабр {{---}} статья пользователя Yruslan "Что нужно знать про арифметику с плавающей запятой"]
*[http://www.sgu.ru/prcnit/teach/3.php Статья Лапшевой Е.Е. "Машинная арифметика с вещественными числами"]

'''На английском'''
*[http://en.wikipedia.org/wiki/NaN Wikipedia {{---}} NaN]
*[http://en.wikipedia.org/wiki/Floating_point Wikipedia {{---}} Floating point]
*[http://en.wikipedia.org/wiki/IEEE_754-2008 Wikipedia {{---}} IEEE 754-2008]

=== Что стоит прочесть ===
* [http://grouper.ieee.org/groups/754 Материалы по стандарту IEEE 754 ''(англ.)'']
* [http://softelectro.ru/ieee754.html Русский перевод стандарта IEEE 754]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Представление информации]]

Представление вещественных чисел

2015-01-12T17:53:11Z

Паршуков Кирилл:

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

Число с плавающей запятой состоит из набора отдельных двоичных разрядов, условно разделенных на так называемые '''знак''' (''sign''), '''порядок''' (''exponent'') и '''мантиссу''' (''mantis''). В наиболее распространённом формате (стандарт IEEE 754) число с плавающей запятой представляется в виде набора битов, часть из которых кодирует собой мантиссу числа, другая часть — показатель степени, и ещё один бит используется для указания знака числа (<tex>0</tex> {{---}} если число положительное, <tex>1</tex> {{---}} если число отрицательное). При этом порядок записывается как целое число в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|коде со сдвигом]], а мантисса {{---}} в [[#Нормальная и нормализованная форма|нормализованном виде]], своей дробной частью в двоичной системе счисления. Вот пример такого числа из <tex>16</tex> двоичных разрядов:
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=10 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0

!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Знак {{---}} один бит, указывающий знак всего числа с плавающей точкой. Порядок и мантисса — целые числа, которые вместе со знаком дают представление числа с плавающей запятой в следующем виде:

<tex>(-1)^S \times M \times B^E</tex>, где <tex>S</tex> {{---}} знак, <tex>B</tex> {{---}} основание, <tex>E</tex> {{---}} порядок, а <tex>M</tex> {{---}} мантисса.
Десятичное число, записываемое как <tex> ReE</tex>, где <tex>R</tex> {{---}} число в полуинтервале <tex>[1; 10)</tex>, <tex>E</tex> {{---}} степень, в которой стоит множитель <tex>10</tex>; в нормализированной форме модуль <tex>R</tex> будет являться мантиссой, а <tex>E</tex> {{---}} порядком, а <tex>S</tex> будет равно <tex>1</tex> тогда и только тогда, когда <tex>R</tex> принимает отрицательное значение.
Например, в числе <tex>-2435e9</tex>
* <tex>S</tex> = <tex>1</tex>
* <tex>B</tex> = <tex>10</tex>
* <tex>M</tex> = <tex>2435</tex>
* <tex>E</tex> = <tex>9</tex>

Порядок также иногда называют '''экспонентой''' или просто '''показателем степени'''.


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

Так же используется формат хранения чисел с фиксированной точкой, который используется для неточных расчётов. Очевидно, что степень числа не хранится в оперативной памяти, а выделяется место для хранения целого числа. Порядок же задаётся программистом.

== Нормальная и нормализованная форма ==

'''Нормальной формой''' (''normal form'') числа с плавающей запятой называется такая форма, в которой мантисса (без учёта знака) в десятичной системе находится на полуинтервале <tex>[0; 1)</tex>. Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, <tex>0,0001</tex> можно записать в 4 формах — <tex>0,0001</tex>×<tex>10</tex><tex>0</tex>, <tex>0,001</tex>×<tex>10</tex><tex>−1</tex>, <tex>0,01</tex>×<tex>10</tex><tex>−2</tex>, <tex>0,1</tex>×<tex>10</tex><tex>−3</tex>), поэтому распространена также другая форма записи — '''нормализованная''' (''normalized''), в которой мантисса десятичного числа принимает значения от <tex>1</tex> (включительно) до <tex>10</tex> (не включительно), а мантисса двоичного числа принимает значения от <tex>1</tex> (включительно) до <tex>2</tex> (не включительно). То есть в мантиссе слева от запятой до применения порядка находится ровно один знак. В такой форме любое число (кроме <tex>0</tex>) записывается единственным образом. Ноль же представить таким образом невозможно, поэтому стандарт предусматривает специальную последовательность битов для задания числа <tex>0</tex> (а заодно и некоторых других [[#Особые значения чисел с плавающей точкой|полезных чисел]], таких как <tex>-\infty</tex> и <tex>+\infty</tex>).
Так как старший двоичный разряд (целая часть) мантиссы вещественного числа в нормализованном виде всегда равен «<tex>1</tex>», то его можно не записывать, сэкономив таким образом один бит, что и используется в стандарте IEEE 754. В позиционных системах счисления с основанием большим, чем <tex>2</tex> (в троичной, четверичной и др.), этого замечательного свойства нет (ведь целая часть там может быть не только единицей).

== Типы чисел с плавающей точкой (по IEEE 754) ==
=== Число половинной точности (''Binary16'', ''Half precision'') ===

'''Число́ полови́нной то́чности''' — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — <tex>16</tex> бит или <tex>2</tex> байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=3 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=2 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=6 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|со сдвигом]] '''<tex>-15</tex>'''. То есть чтобы получить актуально значение порядка нужно вычесть из него сдвиг. Сдвиг можно получить по формуле <tex>2^{b-1}-1</tex>, где <tex>b</tex> {{---}} число бит, отведенное на хранение порядка (в случае числа половинной точности <tex>b=5</tex>).

'''Ограничения точности'''
* Целые от нуля до <tex>2048</tex> передаются как есть.
* Целые от <tex>2049</tex> до <tex>4096</tex> округляются к ближайшему чётному целому.
* Целые от <tex>4097</tex> до <tex>8192</tex> округляются до ближайшего целого, делящегося нацело на четыре.
* Целые от <tex>8193</tex> до <tex>16384</tex> округляются до ближайшего целого, делящегося на восемь.
* Целые от <tex>16385</tex> до <tex>32768</tex> округляются до ближайшего целого, делящегося на шестнадцать.
* Целые от <tex>32769</tex> до <tex>65535</tex> округляются до ближайшего целого, делящегося на тридцать два.

=== Число одинарной точности (''Binary32'', ''Single precision'', ''float'') ===

'''Число́ одина́рной то́чности''' — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — <tex>32</tex> бита или <tex>4</tex> байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.

{|class="wikitable" style="background-color: transparent; border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=8 style="background-color: lightgreen; border: thin solid black"|Порядок (8 бит)
!colspan=24 style="background-color: lightcoral; border: thin solid black"|Мантисса (23+1 бита)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"|
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|30
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|23
|style="border: none"|
|colspan=20 style="border: none; border-left: 1px solid gray; text-align: left"|22
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-127</tex>'''.

=== Число двойной точности (''Binary64'', ''Double precision'', ''double'') ===

'''Число́ двойно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — <tex>64</tex> бита или <tex>8</tex> байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=11 style="background-color: lightgreen; border: thin solid black"|Порядок (11 бит)
!colspan=53 style="background-color: lightcoral; border: thin solid black"|Мантисса (52+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|62
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|52
|style="border: none"|
|colspan=48 style="border: none; border-left: 1px solid gray; text-align: left"|51
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-1023</tex>'''.

=== Число четверной точности (''Binary128'', ''Quadruple precision'') ===

'''Число́ четверно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — <tex>128</tex> бит или <tex>16</tex> байт). Используется в случае необходимости крайне высокой точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=15 style="background-color: lightgreen; border: thin solid black"|Порядок (15 бит)
!colspan=47 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=8 style="border: none; border-left: 1px solid gray; text-align: left"|126
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|112
|style="border: none"|
|colspan=38 style="border: none; border-left: 1px solid gray; text-align: left"|111
|}
 
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=66 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|colspan=66 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-16383</tex>'''.

Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки (но присутствует в процессоре Intel). Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью).
В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.

=== Диапазон значений чисел с плавающей запятой ===
Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, "не число", получается как результат операций типа деления нуля на ноль) и <tex>\pm\infty</tex>.

Данная таблица только лишь примерно указывает границы допустимых значений, без учета возрастающей погрешности с ростом абсолютного значения и существования [[#Денормализованные числа|денормализованных чисел]].


{| class="wikitable"
!Название в IEEE 754|| Название типа переменной в Си || Диапазон значений || Бит в мантиссе || Бит на переменную
|-
|Half precision||-||6,10×10-5..65504||11||16
|-
|Single presicion||float||3,4×10-38..3,4×1038||23||32
|-
|Double precision||double||1,7×10-308..1,7×10308||53||64
|-
|Extended precision||На некоторых архитектурах long double||3,4×10-4932..3,4×104932||65||80
|}

== Особые значения чисел с плавающей точкой ==
=== Ноль (со знаком) ===
Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль. Поэтому для его представления зарезервированы специальные значения мантиссы и порядка {{---}} число считается нулём, если все его биты, кроме знакового, равны нулю. При этом в зависимости от значения бита знака ноль может быть как положительным, так и отрицательным.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm0</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

'''Арифметика нуля со знаком'''
 
Арифметика отрицательного нуля аналогична таковой для любого отрицательного числа и понятна интуитивно. Вот несколько примеров:

* <tex>\frac{-0}{ \left| x \right| } = -0\,\!</tex> (если <tex>x\ne0</tex>)

* <tex>(-0) \cdot (-0) = +0\,\!</tex>

* <tex>\left| x \right| \cdot (-0) = -0\,\!</tex>

* <tex>x + (\pm 0) = x\,\!</tex>

* <tex>(-0) + (-0) = -0\,\!</tex>

* <tex>(+0) + (+0) = +0\,\!</tex>

* <tex>\frac{-0}{-\infty} = +0\,\!</tex>

* <tex>\frac{\left|x\right|}{-0} = -\infty\,\!</tex> (если <tex>x\ne0</tex>)

=== Неопределенность (''NaN'') ===
'''NaN''' {{---}} это аббревиатура от фразы "''not a number''". NaN является результатом арифметических операций, если во время их выполнения произошла ошибка (примеры см. ниже). В IEEE 754 NaN представлен как число, в котором все двоичные разряды порядка {{---}} единицы, а мантисса не нулевая.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: transparent; border: none"| = <tex>NaN</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.

'''Как можно получить NaN?'''
 

* <tex>\infty+(-\infty)= NaN</tex>

* <tex>0\times\infty= NaN</tex>

* <tex>\frac{\pm0}{\pm0}=\frac{\pm\infty}{\pm\infty} = NaN</tex>

* <tex>\sqrt{x} = NaN</tex>, где <tex>x<0</tex>

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

По определению NaN ≠ NaN, поэтому, для проверки значения переменной нужно просто сравнить ее с собой.


=== Бесконечности ===
В число с плавающей запятой можно записать значение <tex>+\infty</tex> или <tex>-\infty</tex>. Как и нули со знаком, бесконечности позволяют получить хотя бы близкий к правильному результат вычисления в случае переполнения. Согласно стандарту IEEE 754 число с плавающей запятой считается равным бесконечности, если все двоичные разряды его порядка {{---}} единицы, а мантисса равна нулю. Знак бесконечности определяется знаковым битом числа.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm\infty</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Получить бесконечность можно при переполнении и при делении ненулевого числа на ноль. При этом
<tex dpi = "180">
\frac{x}{0}
</tex>
<tex>=
\begin{cases}
+\infty,&\text{если $x>0$;}\\
NaN,&\text{если $x=0$;}\\
-\infty,&\text{если $x<0$.}
\end{cases}

</tex>

=== Денормализованные числа ===
'''Денормализованные числа''' (''denormalized/subnormal numbers'') - это способ увеличить количество представимых числом с плавающей запятой значений около нуля, дабы повысить точность вычислений. Каждое значение денормализованного числа меньше самого маленького '''нормализованного''' ("обычного") значения числа с плавающей запятой.
Согласно стандарту, если порядок равен своему минимальному значению (все его биты {{---}} нули, а истинное значение порядка равно его сдвигу) и все биты мантиссы равны нулю, то это <tex>\pm0</tex>. Если же мантисса не равна нулю, то это число с порядком, на единицу большим минимального (все биты порядка, кроме младшего {{---}} нули) и данной мантиссой, '''целая часть которой считается равной нулю, а не единице'''.

То есть число с плавающей запятой, при учете вышесказанного, можно задать следующим образом:
 
* <tex>(-1)^s\times1.M\times2^E</tex>, если <tex>E_{min} \le E \le E_{max}</tex> (''нормализованное число'')

* <tex>(-1)^s\times0.M\times2^{E_{min}}</tex>, если <tex>E=E_{min}-1</tex> (''денормализованное число'')

Где <tex>s</tex> {{---}} бит знака, <tex>M</tex> {{---}} последовательность битов мантиссы, <tex>E</tex> {{---}} значение порядка (с учетом сдвига), <tex>E_{min}</tex> {{---}} минимальное значение порядка, используемое для записи чисел (1 {{---}} ''сдвиг'') , <tex>E_{min}-1</tex> {{---}} минимальное значение порядка, которое он в принципе может принять (все биты нули, 0 {{---}} ''сдвиг'').

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

В современных процессорах обработка денормализованных чисел происходит в десятки раз медленнее, чем обработка нормализованных чисел. Ниже приведена часть таблицы из [http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf статьи Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values" ''(англ.)'']

{| class="wikitable"
!Производитель||Процессор||Замедление (разы)
|-
|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-х разрядном формате <tex>-269</tex> <tex>7</tex>/<tex>32</tex> и <tex>405,875</tex>.
Переведем <tex>-269</tex> <tex>7</tex>/<tex>32</tex> в машинный вид. Для этого сначала переведем его в двоичную систему счисления.
<tex>-269</tex> <tex>7</tex>/<tex>32</tex> = <tex>-269,21875</tex>
<tex>-269,21875</tex><tex>10</tex> = <tex>-100001101,00111</tex><tex>2</tex>

Нормализуем полученное двоичное число по правилам машинной арифметики.
<tex>-100001101{,}00111</tex> = <tex>-1{,}0000110100111</tex> × <tex>10</tex><tex>1000</tex>

Найдем смещенный порядок. Так как в условии говорится о 32-разрядном представлении, то смещение порядка равно <tex>127</tex><tex>10</tex>.
E = <tex>8</tex><tex>10</tex> + <tex>127</tex><tex>10</tex> = <tex>1000</tex><tex>2</tex> + <tex>1111111</tex><tex>2</tex> = <tex>10000111</tex><tex>2</tex>

Число отрицательное, следовательно, в бите знака будет стоять единица.

Итак, первое число в машинном 32-разрядном представлении с плавающей точкой будет иметь вид:
<tex>1</tex>10000111<tex>00001101001110000000000</tex> (жирным шрифтом выделен порядок числа, длина мантиссы {{---}} 23 бита).

Переведем второе число в машинный вид, совершая те же действия.

<tex>405,87510</tex> = <tex>110010101</tex>,<tex>111000000000011010</tex>...<tex>2</tex> = <tex>1,10010101111000000000011010</tex>... × <tex>10</tex><tex>1000</tex>
В качестве мантиссы будут сохранены первые <tex>23</tex> бита после запятой т.е. <tex>10010101111000000000011</tex>.
Очевидно, что порядок со смещением у второго числа будет таким же, как и у первого.

Второе число положительное, следовательно, бит знака будет содержать ноль.

Итак в машинном 32-разрядном представлении второе число будет иметь вид:

<tex>0</tex>10000111<tex>10010101111000000000011</tex>
Далее в арифметических операциях будет использоваться число <tex>110010101</tex>,<tex>111</tex><tex>2</tex>=<tex>405</tex>.<tex>875</tex><tex>10</tex>, а не <tex>110010101</tex>,<tex>111000000000011</tex><tex>2</tex>=<tex>405</tex>,<tex>87510</tex><tex>10</tex> видимо для упрощения(хотя это не совсем корректно).

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

<tex>1</tex>,<tex>1001010111100</tex><tex>2</tex> - <tex>1</tex>,<tex>0000110100111</tex><tex>2</tex> = <tex>0</tex>,<tex>1000100010101</tex><tex>2</tex>

Приводим полученный результат к машинному виду. Для этого мы должны внести поправку в порядок {{---}} уменьшить его на единицу.
Знак результата {{---}} положительный, следовательно, бит знака содержит ноль.

<tex>0</tex>10000110<tex>00010001010100000000000</tex>

Проверим правильность наших вычислений. Переведем результат в десятичное представление.

Найдем реальный порядок результата, вычтя из него значение смещения <tex>127</tex><tex>10</tex>.

E = <tex>10000110</tex><tex>2</tex> - <tex>1111111</tex><tex>2</tex> = <tex>134</tex><tex>10</tex> - <tex>127</tex><tex>10</tex> = <tex>7</tex><tex>10</tex> = <tex>111</tex><tex>2</tex>

Следовательно, число результата будет иметь вид:
A = <tex>1</tex>,<tex>000100010101</tex> × <tex>10</tex><tex>111</tex> = <tex>10001000</tex>,<tex>10101</tex><tex>2</tex> = <tex>136</tex>,<tex>65625</tex><tex>10</tex>

Результат наших вычислений верен, так как <tex>405</tex>,<tex>875</tex> - <tex>269</tex>,<tex>21875</tex> = <tex>136</tex>,<tex>65625</tex>.

=== Алгоритм получения представления вещественного числа в памяти ЭВМ ===

Покажем преобразование действительного числа для представления его в

памяти ЭВМ на примере величины типа Double.

Как видно из таблицы, величина этого типа занимает в памяти <tex>8</tex> байт. На

рисунке ниже показано, как здесь представлены поля мантиссы и порядка (нумерация битов осуществляется справа налево):

{|class="wikitable"
!Знак || Смещённый порядок || Мантисса
|-
|63 || 62..52 || 51..0
|}

Можно заметить, что старший бит, отведенный под мантиссу, имеет номер

<tex>51</tex>, т.е. мантисса занимает младшие <tex>52</tex> бита. Черта указывает здесь на

положение двоичной запятой. Перед запятой должен стоять бит целой части

мантиссы, но поскольку она всегда равна <tex>1</tex>, здесь данный бит не требуется и

соответствующий разряд отсутствует в памяти (но он подразумевается).

Значение порядка хранится здесь не как целое число, представленное в

дополнительном коде. Для упрощения вычислений и сравнения действительных

чисел значение порядка в ЭВМ хранится в виде смещенного числа, т.е. к

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

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

соответствовал нуль. Например, для типа Double порядок занимает <tex>11</tex> бит и

имеет диапазон от <tex>2</tex><tex>-1023</tex> до <tex>2</tex><tex>1023</tex>, поэтому смещение равно <tex>1023</tex>(<tex>10</tex>) =

<tex>1111111111</tex>(<tex>2</tex>). Наконец, бит с номером <tex>63</tex> указывает на знак числа.

Таким образом, из вышесказанного вытекает следующий алгоритм для

получения представления действительного числа в памяти ЭВМ:

<OL>

<LI>перевести модуль данного числа в двоичную систему счисления;</LI>

<LI>нормализовать двоичное число, т.е. записать в виде M × 2p, где M 

мантисса (ее целая часть равна <tex>1</tex>(<tex>2</tex>)) и p  порядок, записанный в

десятичной системе счисления;</LI>

<LI>прибавить к порядку смещение и перевести смещенный порядок в двоичную

систему счисления;</LI>

<LI>учитывая знак заданного числа (0  положительное; 1  отрицательное),

выписать его представление в памяти ЭВМ.</LI>

</OL>

Пример. Запишем код числа <tex>-312</tex>,<tex>3125</tex>.

<OL>

<LI>Двоичная запись модуля этого числа имеет вид <tex>100111000</tex>,<tex>0101</tex>.</LI>

<LI>Имеем <tex>100111000</tex>,<tex>0101</tex> =

<tex>1</tex>,<tex>001110000101</tex> × <tex>2</tex><tex>8</tex>.</LI>

<LI>Получаем смещенный порядок <tex>8</tex> + <tex>1023</tex> = <tex>1031</tex>. Далее имеем

<tex>1031</tex>(<tex>10</tex>) = <tex>10000000111</tex>(<tex>2</tex>).</LI>

<LI>Окончательно

{|class="wikitable"
| 1 || 10000000111 || 0011100001010000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

</LI>

</OL>

Очевидно, что более компактно полученный код стоит записать следующим

образом: C073850000000000(16).

Другой пример иллюстрирует обратный переход от кода действительного

числа к самому числу.

Пример. Пусть дан код 3FEC600000000000(16) или

<OL>

{|class="wikitable"
| 0 || 01111111110 || 1100011000000000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

<LI>Прежде всего замечаем, что это код положительного числа, поскольку в

разряде с номером <tex>63</tex> записан нуль. Получим порядок этого числа:

<tex>01111111110</tex>(<tex>2</tex>) = <tex>1022</tex>(<tex>10</tex>); <tex>1022</tex> - <tex>1023</tex> = <tex>-1</tex>.</LI>

<LI>Число имеет вид <tex>1</tex>,<tex>1100011</tex> × <tex>2</tex><tex>-1</tex> или

<tex>0</tex>,<tex>11100011</tex>.</LI>

<LI>Переводом в десятичную систему счисления получаем <tex>0</tex>,<tex>88671875</tex>.</LI>

</OL>

== См. также ==
* [[Представление символов, таблицы кодировок]]
* [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]

== Примечания ==
[http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf Статья Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values"]

== Ссылки ==
=== Использованные материалы ===
'''На русском'''
* [http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C Википедия {{---}} Экспоненциальная запись]
* [http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D0%B7%D0%B0%D0%BF%D1%8F%D1%82%D0%BE%D0%B9 Википедия {{---}} Число с плавающей запятой]
* [http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%80%D0%B8%D1%86%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BD%D0%BE%D0%BB%D1%8C Википедия {{---}} Отрицательный и положительный ноль]
*[http://habrahabr.ru/blogs/cpp/112953/ Хабрахабр {{---}} статья пользователя Yruslan "Что нужно знать про арифметику с плавающей запятой"]
*[http://www.sgu.ru/prcnit/teach/3.php Статья Лапшевой Е.Е. "Машинная арифметика с вещественными числами"]

'''На английском'''
*[http://en.wikipedia.org/wiki/NaN Wikipedia {{---}} NaN]
*[http://en.wikipedia.org/wiki/Floating_point Wikipedia {{---}} Floating point]
*[http://en.wikipedia.org/wiki/IEEE_754-2008 Wikipedia {{---}} IEEE 754-2008]

=== Что стоит прочесть ===
* [http://grouper.ieee.org/groups/754 Материалы по стандарту IEEE 754 ''(англ.)'']
* [http://softelectro.ru/ieee754.html Русский перевод стандарта IEEE 754]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Представление информации]]

Представление вещественных чисел

2015-01-12T17:51:54Z

Паршуков Кирилл:

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

Число с плавающей запятой состоит из набора отдельных двоичных разрядов, условно разделенных на так называемые '''знак''' (''sign''), '''порядок''' (''exponent'') и '''мантиссу''' (''mantis''). В наиболее распространённом формате (стандарт IEEE 754) число с плавающей запятой представляется в виде набора битов, часть из которых кодирует собой мантиссу числа, другая часть — показатель степени, и ещё один бит используется для указания знака числа (<tex>0</tex> {{---}} если число положительное, <tex>1</tex> {{---}} если число отрицательное). При этом порядок записывается как целое число в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|коде со сдвигом]], а мантисса {{---}} в [[#Нормальная и нормализованная форма|нормализованном виде]], своей дробной частью в двоичной системе счисления. Вот пример такого числа из <tex>16</tex> двоичных разрядов:
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=10 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0

!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Знак {{---}} один бит, указывающий знак всего числа с плавающей точкой. Порядок и мантисса — целые числа, которые вместе со знаком дают представление числа с плавающей запятой в следующем виде:

<tex>(-1)^S \times M \times B^E</tex>, где <tex>S</tex> {{---}} знак, <tex>B</tex> {{---}} основание, <tex>E</tex> {{---}} порядок, а <tex>M</tex> {{---}} мантисса.
Десятичное число, записываемое как <tex> ReE</tex>, где <tex>R</tex> {{---}} число в полуинтервале <tex>[1; 10)</tex>, <tex>E</tex> {{---}} степень, в которой стоит множитель <tex>10</tex>;
в нормализированной форме модуль <tex>R</tex> будет являться мантиссой, а <tex>E</tex> {{---}} порядком, а <tex>S</tex> будет равно <tex>1</tex> тогда и только тогда, когда <tex>R</tex> принимает отрицательное значение.
Например, в числе <tex>-2435e9</tex>
* <tex>S</tex> = <tex>1</tex>
* <tex>B</tex> = <tex>10</tex>
* <tex>M</tex> = <tex>2435</tex>
* <tex>E</tex> = <tex>9</tex>

Порядок также иногда называют '''экспонентой''' или просто '''показателем степени'''.


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

Так же используется формат хранения чисел с фиксированной точкой, который используется для неточных расчётов. Очевидно, что степень числа не хранится в оперативной памяти, а выделяется место для хранения целого числа. Порядок же задаётся программистом.

== Нормальная и нормализованная форма ==

'''Нормальной формой''' (''normal form'') числа с плавающей запятой называется такая форма, в которой мантисса (без учёта знака) в десятичной системе находится на полуинтервале <tex>[0; 1)</tex>. Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, <tex>0,0001</tex> можно записать в 4 формах — <tex>0,0001</tex>×<tex>10</tex><tex>0</tex>, <tex>0,001</tex>×<tex>10</tex><tex>−1</tex>, <tex>0,01</tex>×<tex>10</tex><tex>−2</tex>, <tex>0,1</tex>×<tex>10</tex><tex>−3</tex>), поэтому распространена также другая форма записи — '''нормализованная''' (''normalized''), в которой мантисса десятичного числа принимает значения от <tex>1</tex> (включительно) до <tex>10</tex> (не включительно), а мантисса двоичного числа принимает значения от <tex>1</tex> (включительно) до <tex>2</tex> (не включительно). То есть в мантиссе слева от запятой до применения порядка находится ровно один знак. В такой форме любое число (кроме <tex>0</tex>) записывается единственным образом. Ноль же представить таким образом невозможно, поэтому стандарт предусматривает специальную последовательность битов для задания числа <tex>0</tex> (а заодно и некоторых других [[#Особые значения чисел с плавающей точкой|полезных чисел]], таких как <tex>-\infty</tex> и <tex>+\infty</tex>).
Так как старший двоичный разряд (целая часть) мантиссы вещественного числа в нормализованном виде всегда равен «<tex>1</tex>», то его можно не записывать, сэкономив таким образом один бит, что и используется в стандарте IEEE 754. В позиционных системах счисления с основанием большим, чем <tex>2</tex> (в троичной, четверичной и др.), этого замечательного свойства нет (ведь целая часть там может быть не только единицей).

== Типы чисел с плавающей точкой (по IEEE 754) ==
=== Число половинной точности (''Binary16'', ''Half precision'') ===

'''Число́ полови́нной то́чности''' — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — <tex>16</tex> бит или <tex>2</tex> байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=3 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=2 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=6 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|со сдвигом]] '''<tex>-15</tex>'''. То есть чтобы получить актуально значение порядка нужно вычесть из него сдвиг. Сдвиг можно получить по формуле <tex>2^{b-1}-1</tex>, где <tex>b</tex> {{---}} число бит, отведенное на хранение порядка (в случае числа половинной точности <tex>b=5</tex>).

'''Ограничения точности'''
* Целые от нуля до <tex>2048</tex> передаются как есть.
* Целые от <tex>2049</tex> до <tex>4096</tex> округляются к ближайшему чётному целому.
* Целые от <tex>4097</tex> до <tex>8192</tex> округляются до ближайшего целого, делящегося нацело на четыре.
* Целые от <tex>8193</tex> до <tex>16384</tex> округляются до ближайшего целого, делящегося на восемь.
* Целые от <tex>16385</tex> до <tex>32768</tex> округляются до ближайшего целого, делящегося на шестнадцать.
* Целые от <tex>32769</tex> до <tex>65535</tex> округляются до ближайшего целого, делящегося на тридцать два.

=== Число одинарной точности (''Binary32'', ''Single precision'', ''float'') ===

'''Число́ одина́рной то́чности''' — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — <tex>32</tex> бита или <tex>4</tex> байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.

{|class="wikitable" style="background-color: transparent; border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=8 style="background-color: lightgreen; border: thin solid black"|Порядок (8 бит)
!colspan=24 style="background-color: lightcoral; border: thin solid black"|Мантисса (23+1 бита)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"|
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|30
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|23
|style="border: none"|
|colspan=20 style="border: none; border-left: 1px solid gray; text-align: left"|22
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-127</tex>'''.

=== Число двойной точности (''Binary64'', ''Double precision'', ''double'') ===

'''Число́ двойно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — <tex>64</tex> бита или <tex>8</tex> байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=11 style="background-color: lightgreen; border: thin solid black"|Порядок (11 бит)
!colspan=53 style="background-color: lightcoral; border: thin solid black"|Мантисса (52+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|62
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|52
|style="border: none"|
|colspan=48 style="border: none; border-left: 1px solid gray; text-align: left"|51
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-1023</tex>'''.

=== Число четверной точности (''Binary128'', ''Quadruple precision'') ===

'''Число́ четверно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — <tex>128</tex> бит или <tex>16</tex> байт). Используется в случае необходимости крайне высокой точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=15 style="background-color: lightgreen; border: thin solid black"|Порядок (15 бит)
!colspan=47 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=8 style="border: none; border-left: 1px solid gray; text-align: left"|126
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|112
|style="border: none"|
|colspan=38 style="border: none; border-left: 1px solid gray; text-align: left"|111
|}
 
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=66 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|colspan=66 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-16383</tex>'''.

Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки (но присутствует в процессоре Intel). Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью).
В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.

=== Диапазон значений чисел с плавающей запятой ===
Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, "не число", получается как результат операций типа деления нуля на ноль) и <tex>\pm\infty</tex>.

Данная таблица только лишь примерно указывает границы допустимых значений, без учета возрастающей погрешности с ростом абсолютного значения и существования [[#Денормализованные числа|денормализованных чисел]].


{| class="wikitable"
!Название в IEEE 754|| Название типа переменной в Си || Диапазон значений || Бит в мантиссе || Бит на переменную
|-
|Half precision||-||6,10×10-5..65504||11||16
|-
|Single presicion||float||3,4×10-38..3,4×1038||23||32
|-
|Double precision||double||1,7×10-308..1,7×10308||53||64
|-
|Extended precision||На некоторых архитектурах long double||3,4×10-4932..3,4×104932||65||80
|}

== Особые значения чисел с плавающей точкой ==
=== Ноль (со знаком) ===
Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль. Поэтому для его представления зарезервированы специальные значения мантиссы и порядка {{---}} число считается нулём, если все его биты, кроме знакового, равны нулю. При этом в зависимости от значения бита знака ноль может быть как положительным, так и отрицательным.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm0</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

'''Арифметика нуля со знаком'''
 
Арифметика отрицательного нуля аналогична таковой для любого отрицательного числа и понятна интуитивно. Вот несколько примеров:

* <tex>\frac{-0}{ \left| x \right| } = -0\,\!</tex> (если <tex>x\ne0</tex>)

* <tex>(-0) \cdot (-0) = +0\,\!</tex>

* <tex>\left| x \right| \cdot (-0) = -0\,\!</tex>

* <tex>x + (\pm 0) = x\,\!</tex>

* <tex>(-0) + (-0) = -0\,\!</tex>

* <tex>(+0) + (+0) = +0\,\!</tex>

* <tex>\frac{-0}{-\infty} = +0\,\!</tex>

* <tex>\frac{\left|x\right|}{-0} = -\infty\,\!</tex> (если <tex>x\ne0</tex>)

=== Неопределенность (''NaN'') ===
'''NaN''' {{---}} это аббревиатура от фразы "''not a number''". NaN является результатом арифметических операций, если во время их выполнения произошла ошибка (примеры см. ниже). В IEEE 754 NaN представлен как число, в котором все двоичные разряды порядка {{---}} единицы, а мантисса не нулевая.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: transparent; border: none"| = <tex>NaN</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.

'''Как можно получить NaN?'''
 

* <tex>\infty+(-\infty)= NaN</tex>

* <tex>0\times\infty= NaN</tex>

* <tex>\frac{\pm0}{\pm0}=\frac{\pm\infty}{\pm\infty} = NaN</tex>

* <tex>\sqrt{x} = NaN</tex>, где <tex>x<0</tex>

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

По определению NaN ≠ NaN, поэтому, для проверки значения переменной нужно просто сравнить ее с собой.


=== Бесконечности ===
В число с плавающей запятой можно записать значение <tex>+\infty</tex> или <tex>-\infty</tex>. Как и нули со знаком, бесконечности позволяют получить хотя бы близкий к правильному результат вычисления в случае переполнения. Согласно стандарту IEEE 754 число с плавающей запятой считается равным бесконечности, если все двоичные разряды его порядка {{---}} единицы, а мантисса равна нулю. Знак бесконечности определяется знаковым битом числа.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm\infty</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Получить бесконечность можно при переполнении и при делении ненулевого числа на ноль. При этом
<tex dpi = "180">
\frac{x}{0}
</tex>
<tex>=
\begin{cases}
+\infty,&\text{если $x>0$;}\\
NaN,&\text{если $x=0$;}\\
-\infty,&\text{если $x<0$.}
\end{cases}

</tex>

=== Денормализованные числа ===
'''Денормализованные числа''' (''denormalized/subnormal numbers'') - это способ увеличить количество представимых числом с плавающей запятой значений около нуля, дабы повысить точность вычислений. Каждое значение денормализованного числа меньше самого маленького '''нормализованного''' ("обычного") значения числа с плавающей запятой.
Согласно стандарту, если порядок равен своему минимальному значению (все его биты {{---}} нули, а истинное значение порядка равно его сдвигу) и все биты мантиссы равны нулю, то это <tex>\pm0</tex>. Если же мантисса не равна нулю, то это число с порядком, на единицу большим минимального (все биты порядка, кроме младшего {{---}} нули) и данной мантиссой, '''целая часть которой считается равной нулю, а не единице'''.

То есть число с плавающей запятой, при учете вышесказанного, можно задать следующим образом:
 
* <tex>(-1)^s\times1.M\times2^E</tex>, если <tex>E_{min} \le E \le E_{max}</tex> (''нормализованное число'')

* <tex>(-1)^s\times0.M\times2^{E_{min}}</tex>, если <tex>E=E_{min}-1</tex> (''денормализованное число'')

Где <tex>s</tex> {{---}} бит знака, <tex>M</tex> {{---}} последовательность битов мантиссы, <tex>E</tex> {{---}} значение порядка (с учетом сдвига), <tex>E_{min}</tex> {{---}} минимальное значение порядка, используемое для записи чисел (1 {{---}} ''сдвиг'') , <tex>E_{min}-1</tex> {{---}} минимальное значение порядка, которое он в принципе может принять (все биты нули, 0 {{---}} ''сдвиг'').

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

В современных процессорах обработка денормализованных чисел происходит в десятки раз медленнее, чем обработка нормализованных чисел. Ниже приведена часть таблицы из [http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf статьи Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values" ''(англ.)'']

{| class="wikitable"
!Производитель||Процессор||Замедление (разы)
|-
|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-х разрядном формате <tex>-269</tex> <tex>7</tex>/<tex>32</tex> и <tex>405,875</tex>.
Переведем <tex>-269</tex> <tex>7</tex>/<tex>32</tex> в машинный вид. Для этого сначала переведем его в двоичную систему счисления.
<tex>-269</tex> <tex>7</tex>/<tex>32</tex> = <tex>-269,21875</tex>
<tex>-269,21875</tex><tex>10</tex> = <tex>-100001101,00111</tex><tex>2</tex>

Нормализуем полученное двоичное число по правилам машинной арифметики.
<tex>-100001101{,}00111</tex> = <tex>-1{,}0000110100111</tex> × <tex>10</tex><tex>1000</tex>

Найдем смещенный порядок. Так как в условии говорится о 32-разрядном представлении, то смещение порядка равно <tex>127</tex><tex>10</tex>.
E = <tex>8</tex><tex>10</tex> + <tex>127</tex><tex>10</tex> = <tex>1000</tex><tex>2</tex> + <tex>1111111</tex><tex>2</tex> = <tex>10000111</tex><tex>2</tex>

Число отрицательное, следовательно, в бите знака будет стоять единица.

Итак, первое число в машинном 32-разрядном представлении с плавающей точкой будет иметь вид:
<tex>1</tex>10000111<tex>00001101001110000000000</tex> (жирным шрифтом выделен порядок числа, длина мантиссы {{---}} 23 бита).

Переведем второе число в машинный вид, совершая те же действия.

<tex>405,87510</tex> = <tex>110010101</tex>,<tex>111000000000011010</tex>...<tex>2</tex> = <tex>1,10010101111000000000011010</tex>... × <tex>10</tex><tex>1000</tex>
В качестве мантиссы будут сохранены первые <tex>23</tex> бита после запятой т.е. <tex>10010101111000000000011</tex>.
Очевидно, что порядок со смещением у второго числа будет таким же, как и у первого.

Второе число положительное, следовательно, бит знака будет содержать ноль.

Итак в машинном 32-разрядном представлении второе число будет иметь вид:

<tex>0</tex>10000111<tex>10010101111000000000011</tex>
Далее в арифметических операциях будет использоваться число <tex>110010101</tex>,<tex>111</tex><tex>2</tex>=<tex>405</tex>.<tex>875</tex><tex>10</tex>, а не <tex>110010101</tex>,<tex>111000000000011</tex><tex>2</tex>=<tex>405</tex>,<tex>87510</tex><tex>10</tex> видимо для упрощения(хотя это не совсем корректно).

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

<tex>1</tex>,<tex>1001010111100</tex><tex>2</tex> - <tex>1</tex>,<tex>0000110100111</tex><tex>2</tex> = <tex>0</tex>,<tex>1000100010101</tex><tex>2</tex>

Приводим полученный результат к машинному виду. Для этого мы должны внести поправку в порядок {{---}} уменьшить его на единицу.
Знак результата {{---}} положительный, следовательно, бит знака содержит ноль.

<tex>0</tex>10000110<tex>00010001010100000000000</tex>

Проверим правильность наших вычислений. Переведем результат в десятичное представление.

Найдем реальный порядок результата, вычтя из него значение смещения <tex>127</tex><tex>10</tex>.

E = <tex>10000110</tex><tex>2</tex> - <tex>1111111</tex><tex>2</tex> = <tex>134</tex><tex>10</tex> - <tex>127</tex><tex>10</tex> = <tex>7</tex><tex>10</tex> = <tex>111</tex><tex>2</tex>

Следовательно, число результата будет иметь вид:
A = <tex>1</tex>,<tex>000100010101</tex> × <tex>10</tex><tex>111</tex> = <tex>10001000</tex>,<tex>10101</tex><tex>2</tex> = <tex>136</tex>,<tex>65625</tex><tex>10</tex>

Результат наших вычислений верен, так как <tex>405</tex>,<tex>875</tex> - <tex>269</tex>,<tex>21875</tex> = <tex>136</tex>,<tex>65625</tex>.

=== Алгоритм получения представления вещественного числа в памяти ЭВМ ===

Покажем преобразование действительного числа для представления его в

памяти ЭВМ на примере величины типа Double.

Как видно из таблицы, величина этого типа занимает в памяти <tex>8</tex> байт. На

рисунке ниже показано, как здесь представлены поля мантиссы и порядка (нумерация битов осуществляется справа налево):

{|class="wikitable"
!Знак || Смещённый порядок || Мантисса
|-
|63 || 62..52 || 51..0
|}

Можно заметить, что старший бит, отведенный под мантиссу, имеет номер

<tex>51</tex>, т.е. мантисса занимает младшие <tex>52</tex> бита. Черта указывает здесь на

положение двоичной запятой. Перед запятой должен стоять бит целой части

мантиссы, но поскольку она всегда равна <tex>1</tex>, здесь данный бит не требуется и

соответствующий разряд отсутствует в памяти (но он подразумевается).

Значение порядка хранится здесь не как целое число, представленное в

дополнительном коде. Для упрощения вычислений и сравнения действительных

чисел значение порядка в ЭВМ хранится в виде смещенного числа, т.е. к

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

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

соответствовал нуль. Например, для типа Double порядок занимает <tex>11</tex> бит и

имеет диапазон от <tex>2</tex><tex>-1023</tex> до <tex>2</tex><tex>1023</tex>, поэтому смещение равно <tex>1023</tex>(<tex>10</tex>) =

<tex>1111111111</tex>(<tex>2</tex>). Наконец, бит с номером <tex>63</tex> указывает на знак числа.

Таким образом, из вышесказанного вытекает следующий алгоритм для

получения представления действительного числа в памяти ЭВМ:

<OL>

<LI>перевести модуль данного числа в двоичную систему счисления;</LI>

<LI>нормализовать двоичное число, т.е. записать в виде M × 2p, где M 

мантисса (ее целая часть равна <tex>1</tex>(<tex>2</tex>)) и p  порядок, записанный в

десятичной системе счисления;</LI>

<LI>прибавить к порядку смещение и перевести смещенный порядок в двоичную

систему счисления;</LI>

<LI>учитывая знак заданного числа (0  положительное; 1  отрицательное),

выписать его представление в памяти ЭВМ.</LI>

</OL>

Пример. Запишем код числа <tex>-312</tex>,<tex>3125</tex>.

<OL>

<LI>Двоичная запись модуля этого числа имеет вид <tex>100111000</tex>,<tex>0101</tex>.</LI>

<LI>Имеем <tex>100111000</tex>,<tex>0101</tex> =

<tex>1</tex>,<tex>001110000101</tex> × <tex>2</tex><tex>8</tex>.</LI>

<LI>Получаем смещенный порядок <tex>8</tex> + <tex>1023</tex> = <tex>1031</tex>. Далее имеем

<tex>1031</tex>(<tex>10</tex>) = <tex>10000000111</tex>(<tex>2</tex>).</LI>

<LI>Окончательно

{|class="wikitable"
| 1 || 10000000111 || 0011100001010000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

</LI>

</OL>

Очевидно, что более компактно полученный код стоит записать следующим

образом: C073850000000000(16).

Другой пример иллюстрирует обратный переход от кода действительного

числа к самому числу.

Пример. Пусть дан код 3FEC600000000000(16) или

<OL>

{|class="wikitable"
| 0 || 01111111110 || 1100011000000000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

<LI>Прежде всего замечаем, что это код положительного числа, поскольку в

разряде с номером <tex>63</tex> записан нуль. Получим порядок этого числа:

<tex>01111111110</tex>(<tex>2</tex>) = <tex>1022</tex>(<tex>10</tex>); <tex>1022</tex> - <tex>1023</tex> = <tex>-1</tex>.</LI>

<LI>Число имеет вид <tex>1</tex>,<tex>1100011</tex> × <tex>2</tex><tex>-1</tex> или

<tex>0</tex>,<tex>11100011</tex>.</LI>

<LI>Переводом в десятичную систему счисления получаем <tex>0</tex>,<tex>88671875</tex>.</LI>

</OL>

== См. также ==
* [[Представление символов, таблицы кодировок]]
* [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]

== Примечания ==
[http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf Статья Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values"]

== Ссылки ==
=== Использованные материалы ===
'''На русском'''
* [http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C Википедия {{---}} Экспоненциальная запись]
* [http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D0%B7%D0%B0%D0%BF%D1%8F%D1%82%D0%BE%D0%B9 Википедия {{---}} Число с плавающей запятой]
* [http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%80%D0%B8%D1%86%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BD%D0%BE%D0%BB%D1%8C Википедия {{---}} Отрицательный и положительный ноль]
*[http://habrahabr.ru/blogs/cpp/112953/ Хабрахабр {{---}} статья пользователя Yruslan "Что нужно знать про арифметику с плавающей запятой"]
*[http://www.sgu.ru/prcnit/teach/3.php Статья Лапшевой Е.Е. "Машинная арифметика с вещественными числами"]

'''На английском'''
*[http://en.wikipedia.org/wiki/NaN Wikipedia {{---}} NaN]
*[http://en.wikipedia.org/wiki/Floating_point Wikipedia {{---}} Floating point]
*[http://en.wikipedia.org/wiki/IEEE_754-2008 Wikipedia {{---}} IEEE 754-2008]

=== Что стоит прочесть ===
* [http://grouper.ieee.org/groups/754 Материалы по стандарту IEEE 754 ''(англ.)'']
* [http://softelectro.ru/ieee754.html Русский перевод стандарта IEEE 754]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Представление информации]]

Представление вещественных чисел

2015-01-12T17:50:51Z

Паршуков Кирилл:

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

Число с плавающей запятой состоит из набора отдельных двоичных разрядов, условно разделенных на так называемые '''знак''' (''sign''), '''порядок''' (''exponent'') и '''мантиссу''' (''mantis''). В наиболее распространённом формате (стандарт IEEE 754) число с плавающей запятой представляется в виде набора битов, часть из которых кодирует собой мантиссу числа, другая часть — показатель степени, и ещё один бит используется для указания знака числа (<tex>0</tex> {{---}} если число положительное, <tex>1</tex> {{---}} если число отрицательное). При этом порядок записывается как целое число в [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|коде со сдвигом]], а мантисса {{---}} в [[#Нормальная и нормализованная форма|нормализованном виде]], своей дробной частью в двоичной системе счисления. Вот пример такого числа из <tex>16</tex> двоичных разрядов:
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=10 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0

!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Знак {{---}} один бит, указывающий знак всего числа с плавающей точкой. Порядок и мантисса — целые числа, которые вместе со знаком дают представление числа с плавающей запятой в следующем виде:

<tex>(-1)^S \times M \times B^E</tex>, где <tex>S</tex> {{---}} знак, <tex>B</tex> {{---}} основание, <tex>E</tex> {{---}} порядок, а <tex>M</tex> {{---}} мантисса.
Десятичное число, записываемое как <tex> ReE</tex>, где <tex>R</tex> {{---}} число в полуинтервале <tex>[1; 10)</tex>, <tex>E</tex> {{---}} степень, в которой стоит множитель <tex>10</tex>;
В нормализированной форме модуль <tex>R</tex> будет являться мантиссой, а <tex>E</tex> {{---}} порядком, а <tex>S</tex> будет равно <tex>1</tex> тогда и только тогда, когда <tex>R</tex> принимает отрицательное значение.
Например, в числе <tex>-2435e9</tex>
* <tex>S</tex> = <tex>1</tex>
* <tex>B</tex> = <tex>10</tex>
* <tex>M</tex> = <tex>2435</tex>
* <tex>E</tex> = <tex>9</tex>

Порядок также иногда называют '''экспонентой''' или просто '''показателем степени'''.


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

Так же используется формат хранения чисел с фиксированной точкой, который используется для неточных расчётов. Очевидно, что степень числа не хранится в оперативной памяти, а выделяется место для хранения целого числа. Порядок же задаётся программистом.

== Нормальная и нормализованная форма ==

'''Нормальной формой''' (''normal form'') числа с плавающей запятой называется такая форма, в которой мантисса (без учёта знака) в десятичной системе находится на полуинтервале <tex>[0; 1)</tex>. Такая форма записи имеет недостаток: некоторые числа записываются неоднозначно (например, <tex>0,0001</tex> можно записать в 4 формах — <tex>0,0001</tex>×<tex>10</tex><tex>0</tex>, <tex>0,001</tex>×<tex>10</tex><tex>−1</tex>, <tex>0,01</tex>×<tex>10</tex><tex>−2</tex>, <tex>0,1</tex>×<tex>10</tex><tex>−3</tex>), поэтому распространена также другая форма записи — '''нормализованная''' (''normalized''), в которой мантисса десятичного числа принимает значения от <tex>1</tex> (включительно) до <tex>10</tex> (не включительно), а мантисса двоичного числа принимает значения от <tex>1</tex> (включительно) до <tex>2</tex> (не включительно). То есть в мантиссе слева от запятой до применения порядка находится ровно один знак. В такой форме любое число (кроме <tex>0</tex>) записывается единственным образом. Ноль же представить таким образом невозможно, поэтому стандарт предусматривает специальную последовательность битов для задания числа <tex>0</tex> (а заодно и некоторых других [[#Особые значения чисел с плавающей точкой|полезных чисел]], таких как <tex>-\infty</tex> и <tex>+\infty</tex>).
Так как старший двоичный разряд (целая часть) мантиссы вещественного числа в нормализованном виде всегда равен «<tex>1</tex>», то его можно не записывать, сэкономив таким образом один бит, что и используется в стандарте IEEE 754. В позиционных системах счисления с основанием большим, чем <tex>2</tex> (в троичной, четверичной и др.), этого замечательного свойства нет (ведь целая часть там может быть не только единицей).

== Типы чисел с плавающей точкой (по IEEE 754) ==
=== Число половинной точности (''Binary16'', ''Half precision'') ===

'''Число́ полови́нной то́чности''' — компьютерный формат представления чисел, занимающий в памяти половину машинного слова (в случае 32-битного компьютера — <tex>16</tex> бит или <tex>2</tex> байта). В силу невысокой точности этот формат представления чисел с плавающей запятой обычно используется в видеокартах, где небольшой размер и высокая скорость работы важнее точности вычислений.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=3 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=2 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=6 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код|со сдвигом]] '''<tex>-15</tex>'''. То есть чтобы получить актуально значение порядка нужно вычесть из него сдвиг. Сдвиг можно получить по формуле <tex>2^{b-1}-1</tex>, где <tex>b</tex> {{---}} число бит, отведенное на хранение порядка (в случае числа половинной точности <tex>b=5</tex>).

'''Ограничения точности'''
* Целые от нуля до <tex>2048</tex> передаются как есть.
* Целые от <tex>2049</tex> до <tex>4096</tex> округляются к ближайшему чётному целому.
* Целые от <tex>4097</tex> до <tex>8192</tex> округляются до ближайшего целого, делящегося нацело на четыре.
* Целые от <tex>8193</tex> до <tex>16384</tex> округляются до ближайшего целого, делящегося на восемь.
* Целые от <tex>16385</tex> до <tex>32768</tex> округляются до ближайшего целого, делящегося на шестнадцать.
* Целые от <tex>32769</tex> до <tex>65535</tex> округляются до ближайшего целого, делящегося на тридцать два.

=== Число одинарной точности (''Binary32'', ''Single precision'', ''float'') ===

'''Число́ одина́рной то́чности''' — компьютерный формат представления чисел, занимающий в памяти одно машинное слово (в случае 32-битного компьютера — <tex>32</tex> бита или <tex>4</tex> байта). Используется для работы с вещественными числами везде, где не нужна очень высокая точность.

{|class="wikitable" style="background-color: transparent; border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=8 style="background-color: lightgreen; border: thin solid black"|Порядок (8 бит)
!colspan=24 style="background-color: lightcoral; border: thin solid black"|Мантисса (23+1 бита)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"|
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|30
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|23
|style="border: none"|
|colspan=20 style="border: none; border-left: 1px solid gray; text-align: left"|22
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-127</tex>'''.

=== Число двойной точности (''Binary64'', ''Double precision'', ''double'') ===

'''Число́ двойно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти два машинных слова (в случае 32-битного компьютера — <tex>64</tex> бита или <tex>8</tex> байт). Часто используется благодаря своей неплохой точности, даже несмотря на двойной расход памяти и сетевого трафика относительно чисел одинарной точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=11 style="background-color: lightgreen; border: thin solid black"|Порядок (11 бит)
!colspan=53 style="background-color: lightcoral; border: thin solid black"|Мантисса (52+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=4 style="border: none; border-left: 1px solid gray; text-align: left"|62
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|52
|style="border: none"|
|colspan=48 style="border: none; border-left: 1px solid gray; text-align: left"|51
|colspan=4 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-1023</tex>'''.

=== Число четверной точности (''Binary128'', ''Quadruple precision'') ===

'''Число́ четверно́й то́чности''' —
компьютерный формат представления чисел, занимающий в памяти четыре машинных слова (в случае 32-битного компьютера — <tex>128</tex> бит или <tex>16</tex> байт). Используется в случае необходимости крайне высокой точности.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=7 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=15 style="background-color: lightgreen; border: thin solid black"|Порядок (15 бит)
!colspan=47 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|style="border: none"|
|colspan=8 style="border: none; border-left: 1px solid gray; text-align: left"|126
|colspan=7 style="border: none; border-right: 1px solid gray; text-align: right"|112
|style="border: none"|
|colspan=38 style="border: none; border-left: 1px solid gray; text-align: left"|111
|}
 
{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=66 style="background-color: lightcoral; border: thin solid black"|Мантисса (112+1 бит)
|-style="text-align: right"
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
|-
|colspan=66 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}
Порядок записан со сдвигом '''<tex>-16383</tex>'''.

Обычно этот формат реализуется программно, случаи аппаратной реализации крайне редки (но присутствует в процессоре Intel). Также не гарантируется поддержка этого типа в языках программирования, хотя кое-где она и реализована (например, компилятор gcc для архитектуры x86 позволяет использовать тип __float128, являющийся программной реализацией числа с четверной точностью).
В совокупности эти факторы делают Quadruple весьма экзотичным и редко встречающимся форматом чисел с плавающей запятой.

=== Диапазон значений чисел с плавающей запятой ===
Диапазон чисел, которые можно записать данным способом, зависит от количества бит, отведённых для представления мантиссы и показателя. Пара значений показателя (когда все разряды нули и когда все разряды единицы) зарезервирована для обеспечения возможности представления специальных чисел. К ним относятся ноль, значения NaN (Not a Number, "не число", получается как результат операций типа деления нуля на ноль) и <tex>\pm\infty</tex>.

Данная таблица только лишь примерно указывает границы допустимых значений, без учета возрастающей погрешности с ростом абсолютного значения и существования [[#Денормализованные числа|денормализованных чисел]].


{| class="wikitable"
!Название в IEEE 754|| Название типа переменной в Си || Диапазон значений || Бит в мантиссе || Бит на переменную
|-
|Half precision||-||6,10×10-5..65504||11||16
|-
|Single presicion||float||3,4×10-38..3,4×1038||23||32
|-
|Double precision||double||1,7×10-308..1,7×10308||53||64
|-
|Extended precision||На некоторых архитектурах long double||3,4×10-4932..3,4×104932||65||80
|}

== Особые значения чисел с плавающей точкой ==
=== Ноль (со знаком) ===
Как уже было оговорено выше, в нормализованной форме числа с плавающей точкой невозможно представить ноль. Поэтому для его представления зарезервированы специальные значения мантиссы и порядка {{---}} число считается нулём, если все его биты, кроме знакового, равны нулю. При этом в зависимости от значения бита знака ноль может быть как положительным, так и отрицательным.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="background-color: lightgreen; border: thin solid black"|0
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm0</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

'''Арифметика нуля со знаком'''
 
Арифметика отрицательного нуля аналогична таковой для любого отрицательного числа и понятна интуитивно. Вот несколько примеров:

* <tex>\frac{-0}{ \left| x \right| } = -0\,\!</tex> (если <tex>x\ne0</tex>)

* <tex>(-0) \cdot (-0) = +0\,\!</tex>

* <tex>\left| x \right| \cdot (-0) = -0\,\!</tex>

* <tex>x + (\pm 0) = x\,\!</tex>

* <tex>(-0) + (-0) = -0\,\!</tex>

* <tex>(+0) + (+0) = +0\,\!</tex>

* <tex>\frac{-0}{-\infty} = +0\,\!</tex>

* <tex>\frac{\left|x\right|}{-0} = -\infty\,\!</tex> (если <tex>x\ne0</tex>)

=== Неопределенность (''NaN'') ===
'''NaN''' {{---}} это аббревиатура от фразы "''not a number''". NaN является результатом арифметических операций, если во время их выполнения произошла ошибка (примеры см. ниже). В IEEE 754 NaN представлен как число, в котором все двоичные разряды порядка {{---}} единицы, а мантисса не нулевая.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: lightcoral; border: thin solid black"|0/1
!style="background-color: transparent; border: none"| = <tex>NaN</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.

'''Как можно получить NaN?'''
 

* <tex>\infty+(-\infty)= NaN</tex>

* <tex>0\times\infty= NaN</tex>

* <tex>\frac{\pm0}{\pm0}=\frac{\pm\infty}{\pm\infty} = NaN</tex>

* <tex>\sqrt{x} = NaN</tex>, где <tex>x<0</tex>

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

По определению NaN ≠ NaN, поэтому, для проверки значения переменной нужно просто сравнить ее с собой.


=== Бесконечности ===
В число с плавающей запятой можно записать значение <tex>+\infty</tex> или <tex>-\infty</tex>. Как и нули со знаком, бесконечности позволяют получить хотя бы близкий к правильному результат вычисления в случае переполнения. Согласно стандарту IEEE 754 число с плавающей запятой считается равным бесконечности, если все двоичные разряды его порядка {{---}} единицы, а мантисса равна нулю. Знак бесконечности определяется знаковым битом числа.

{|class="wikitable" style="border-collapse: collapse; border: none"
|-
!colspan=5 style="background-color: powderblue; border: thin solid black; border-bottom: none"|Знак
|-
!style="background-color: powderblue; border: thin solid black; border-top: none"|
!colspan=5 style="background-color: lightgreen; border: thin solid black"|Порядок
!colspan=11 style="background-color: lightcoral; border: thin solid black"|Мантисса
!style="border: none"|
|-style="text-align: right"
!style="background-color: powderblue; border: thin solid black"|0/1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="background-color: lightgreen; border: thin solid black"|1
!style="border: none"|1,
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: lightcoral; border: thin solid black"|0
!style="background-color: transparent; border: none"| = <tex>\pm\infty</tex>
|-
|style="border: none"|
|colspan=2 style="border: none; border-left: 1px solid gray; text-align: left"|14
|colspan=3 style="border: none; border-right: 1px solid gray; text-align: right"|10
|style="border: none"|
|colspan=5 style="border: none; border-left: 1px solid gray; text-align: left"|9
|colspan=5 style="border: none; border-right: 1px solid gray; text-align: right"|0
|}

Получить бесконечность можно при переполнении и при делении ненулевого числа на ноль. При этом
<tex dpi = "180">
\frac{x}{0}
</tex>
<tex>=
\begin{cases}
+\infty,&\text{если $x>0$;}\\
NaN,&\text{если $x=0$;}\\
-\infty,&\text{если $x<0$.}
\end{cases}

</tex>

=== Денормализованные числа ===
'''Денормализованные числа''' (''denormalized/subnormal numbers'') - это способ увеличить количество представимых числом с плавающей запятой значений около нуля, дабы повысить точность вычислений. Каждое значение денормализованного числа меньше самого маленького '''нормализованного''' ("обычного") значения числа с плавающей запятой.
Согласно стандарту, если порядок равен своему минимальному значению (все его биты {{---}} нули, а истинное значение порядка равно его сдвигу) и все биты мантиссы равны нулю, то это <tex>\pm0</tex>. Если же мантисса не равна нулю, то это число с порядком, на единицу большим минимального (все биты порядка, кроме младшего {{---}} нули) и данной мантиссой, '''целая часть которой считается равной нулю, а не единице'''.

То есть число с плавающей запятой, при учете вышесказанного, можно задать следующим образом:
 
* <tex>(-1)^s\times1.M\times2^E</tex>, если <tex>E_{min} \le E \le E_{max}</tex> (''нормализованное число'')

* <tex>(-1)^s\times0.M\times2^{E_{min}}</tex>, если <tex>E=E_{min}-1</tex> (''денормализованное число'')

Где <tex>s</tex> {{---}} бит знака, <tex>M</tex> {{---}} последовательность битов мантиссы, <tex>E</tex> {{---}} значение порядка (с учетом сдвига), <tex>E_{min}</tex> {{---}} минимальное значение порядка, используемое для записи чисел (1 {{---}} ''сдвиг'') , <tex>E_{min}-1</tex> {{---}} минимальное значение порядка, которое он в принципе может принять (все биты нули, 0 {{---}} ''сдвиг'').

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

В современных процессорах обработка денормализованных чисел происходит в десятки раз медленнее, чем обработка нормализованных чисел. Ниже приведена часть таблицы из [http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf статьи Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values" ''(англ.)'']

{| class="wikitable"
!Производитель||Процессор||Замедление (разы)
|-
|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-х разрядном формате <tex>-269</tex> <tex>7</tex>/<tex>32</tex> и <tex>405,875</tex>.
Переведем <tex>-269</tex> <tex>7</tex>/<tex>32</tex> в машинный вид. Для этого сначала переведем его в двоичную систему счисления.
<tex>-269</tex> <tex>7</tex>/<tex>32</tex> = <tex>-269,21875</tex>
<tex>-269,21875</tex><tex>10</tex> = <tex>-100001101,00111</tex><tex>2</tex>

Нормализуем полученное двоичное число по правилам машинной арифметики.
<tex>-100001101{,}00111</tex> = <tex>-1{,}0000110100111</tex> × <tex>10</tex><tex>1000</tex>

Найдем смещенный порядок. Так как в условии говорится о 32-разрядном представлении, то смещение порядка равно <tex>127</tex><tex>10</tex>.
E = <tex>8</tex><tex>10</tex> + <tex>127</tex><tex>10</tex> = <tex>1000</tex><tex>2</tex> + <tex>1111111</tex><tex>2</tex> = <tex>10000111</tex><tex>2</tex>

Число отрицательное, следовательно, в бите знака будет стоять единица.

Итак, первое число в машинном 32-разрядном представлении с плавающей точкой будет иметь вид:
<tex>1</tex>10000111<tex>00001101001110000000000</tex> (жирным шрифтом выделен порядок числа, длина мантиссы {{---}} 23 бита).

Переведем второе число в машинный вид, совершая те же действия.

<tex>405,87510</tex> = <tex>110010101</tex>,<tex>111000000000011010</tex>...<tex>2</tex> = <tex>1,10010101111000000000011010</tex>... × <tex>10</tex><tex>1000</tex>
В качестве мантиссы будут сохранены первые <tex>23</tex> бита после запятой т.е. <tex>10010101111000000000011</tex>.
Очевидно, что порядок со смещением у второго числа будет таким же, как и у первого.

Второе число положительное, следовательно, бит знака будет содержать ноль.

Итак в машинном 32-разрядном представлении второе число будет иметь вид:

<tex>0</tex>10000111<tex>10010101111000000000011</tex>
Далее в арифметических операциях будет использоваться число <tex>110010101</tex>,<tex>111</tex><tex>2</tex>=<tex>405</tex>.<tex>875</tex><tex>10</tex>, а не <tex>110010101</tex>,<tex>111000000000011</tex><tex>2</tex>=<tex>405</tex>,<tex>87510</tex><tex>10</tex> видимо для упрощения(хотя это не совсем корректно).

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

<tex>1</tex>,<tex>1001010111100</tex><tex>2</tex> - <tex>1</tex>,<tex>0000110100111</tex><tex>2</tex> = <tex>0</tex>,<tex>1000100010101</tex><tex>2</tex>

Приводим полученный результат к машинному виду. Для этого мы должны внести поправку в порядок {{---}} уменьшить его на единицу.
Знак результата {{---}} положительный, следовательно, бит знака содержит ноль.

<tex>0</tex>10000110<tex>00010001010100000000000</tex>

Проверим правильность наших вычислений. Переведем результат в десятичное представление.

Найдем реальный порядок результата, вычтя из него значение смещения <tex>127</tex><tex>10</tex>.

E = <tex>10000110</tex><tex>2</tex> - <tex>1111111</tex><tex>2</tex> = <tex>134</tex><tex>10</tex> - <tex>127</tex><tex>10</tex> = <tex>7</tex><tex>10</tex> = <tex>111</tex><tex>2</tex>

Следовательно, число результата будет иметь вид:
A = <tex>1</tex>,<tex>000100010101</tex> × <tex>10</tex><tex>111</tex> = <tex>10001000</tex>,<tex>10101</tex><tex>2</tex> = <tex>136</tex>,<tex>65625</tex><tex>10</tex>

Результат наших вычислений верен, так как <tex>405</tex>,<tex>875</tex> - <tex>269</tex>,<tex>21875</tex> = <tex>136</tex>,<tex>65625</tex>.

=== Алгоритм получения представления вещественного числа в памяти ЭВМ ===

Покажем преобразование действительного числа для представления его в

памяти ЭВМ на примере величины типа Double.

Как видно из таблицы, величина этого типа занимает в памяти <tex>8</tex> байт. На

рисунке ниже показано, как здесь представлены поля мантиссы и порядка (нумерация битов осуществляется справа налево):

{|class="wikitable"
!Знак || Смещённый порядок || Мантисса
|-
|63 || 62..52 || 51..0
|}

Можно заметить, что старший бит, отведенный под мантиссу, имеет номер

<tex>51</tex>, т.е. мантисса занимает младшие <tex>52</tex> бита. Черта указывает здесь на

положение двоичной запятой. Перед запятой должен стоять бит целой части

мантиссы, но поскольку она всегда равна <tex>1</tex>, здесь данный бит не требуется и

соответствующий разряд отсутствует в памяти (но он подразумевается).

Значение порядка хранится здесь не как целое число, представленное в

дополнительном коде. Для упрощения вычислений и сравнения действительных

чисел значение порядка в ЭВМ хранится в виде смещенного числа, т.е. к

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

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

соответствовал нуль. Например, для типа Double порядок занимает <tex>11</tex> бит и

имеет диапазон от <tex>2</tex><tex>-1023</tex> до <tex>2</tex><tex>1023</tex>, поэтому смещение равно <tex>1023</tex>(<tex>10</tex>) =

<tex>1111111111</tex>(<tex>2</tex>). Наконец, бит с номером <tex>63</tex> указывает на знак числа.

Таким образом, из вышесказанного вытекает следующий алгоритм для

получения представления действительного числа в памяти ЭВМ:

<OL>

<LI>перевести модуль данного числа в двоичную систему счисления;</LI>

<LI>нормализовать двоичное число, т.е. записать в виде M × 2p, где M 

мантисса (ее целая часть равна <tex>1</tex>(<tex>2</tex>)) и p  порядок, записанный в

десятичной системе счисления;</LI>

<LI>прибавить к порядку смещение и перевести смещенный порядок в двоичную

систему счисления;</LI>

<LI>учитывая знак заданного числа (0  положительное; 1  отрицательное),

выписать его представление в памяти ЭВМ.</LI>

</OL>

Пример. Запишем код числа <tex>-312</tex>,<tex>3125</tex>.

<OL>

<LI>Двоичная запись модуля этого числа имеет вид <tex>100111000</tex>,<tex>0101</tex>.</LI>

<LI>Имеем <tex>100111000</tex>,<tex>0101</tex> =

<tex>1</tex>,<tex>001110000101</tex> × <tex>2</tex><tex>8</tex>.</LI>

<LI>Получаем смещенный порядок <tex>8</tex> + <tex>1023</tex> = <tex>1031</tex>. Далее имеем

<tex>1031</tex>(<tex>10</tex>) = <tex>10000000111</tex>(<tex>2</tex>).</LI>

<LI>Окончательно

{|class="wikitable"
| 1 || 10000000111 || 0011100001010000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

</LI>

</OL>

Очевидно, что более компактно полученный код стоит записать следующим

образом: C073850000000000(16).

Другой пример иллюстрирует обратный переход от кода действительного

числа к самому числу.

Пример. Пусть дан код 3FEC600000000000(16) или

<OL>

{|class="wikitable"
| 0 || 01111111110 || 1100011000000000000000000000000000000000000000000000
|-
| 63 || 62..52 || 51..0
|}

<LI>Прежде всего замечаем, что это код положительного числа, поскольку в

разряде с номером <tex>63</tex> записан нуль. Получим порядок этого числа:

<tex>01111111110</tex>(<tex>2</tex>) = <tex>1022</tex>(<tex>10</tex>); <tex>1022</tex> - <tex>1023</tex> = <tex>-1</tex>.</LI>

<LI>Число имеет вид <tex>1</tex>,<tex>1100011</tex> × <tex>2</tex><tex>-1</tex> или

<tex>0</tex>,<tex>11100011</tex>.</LI>

<LI>Переводом в десятичную систему счисления получаем <tex>0</tex>,<tex>88671875</tex>.</LI>

</OL>

== См. также ==
* [[Представление символов, таблицы кодировок]]
* [[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]

== Примечания ==
[http://charm.cs.uiuc.edu/papers/SubnormalOSIHPA06.pdf Статья Isaac Dooley, Laxmikant Kale "Quantifying the Interference Caused by Subnormal Floating-Point Values"]

== Ссылки ==
=== Использованные материалы ===
'''На русском'''
* [http://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D1%81%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C Википедия {{---}} Экспоненциальная запись]
* [http://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D0%B7%D0%B0%D0%BF%D1%8F%D1%82%D0%BE%D0%B9 Википедия {{---}} Число с плавающей запятой]
* [http://ru.wikipedia.org/wiki/%D0%9E%D1%82%D1%80%D0%B8%D1%86%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B8_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B6%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BD%D0%BE%D0%BB%D1%8C Википедия {{---}} Отрицательный и положительный ноль]
*[http://habrahabr.ru/blogs/cpp/112953/ Хабрахабр {{---}} статья пользователя Yruslan "Что нужно знать про арифметику с плавающей запятой"]
*[http://www.sgu.ru/prcnit/teach/3.php Статья Лапшевой Е.Е. "Машинная арифметика с вещественными числами"]

'''На английском'''
*[http://en.wikipedia.org/wiki/NaN Wikipedia {{---}} NaN]
*[http://en.wikipedia.org/wiki/Floating_point Wikipedia {{---}} Floating point]
*[http://en.wikipedia.org/wiki/IEEE_754-2008 Wikipedia {{---}} IEEE 754-2008]

=== Что стоит прочесть ===
* [http://grouper.ieee.org/groups/754 Материалы по стандарту IEEE 754 ''(англ.)'']
* [http://softelectro.ru/ieee754.html Русский перевод стандарта IEEE 754]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Представление информации]]