Как перевести число с плавающей точкой в двоичную систему
Перейти к содержимому

Как перевести число с плавающей точкой в двоичную систему

  • автор:

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

Пример №1 . Представить число 133,54 в форме числа с плавающей точкой.
Решение. Представим число 133.54 в нормализованном экспоненциальном виде:
1.3354*10 2 = 1.3354*exp10 2
Число 1.3354*exp10 2 состоит из двух частей: мантиссы M=1.3354 и экспоненты exp10=2
Если мантисса находится в диапазоне 1 ≤ M 3 Пример №2 . Представить двоичное число 101.102 в нормализованном виде, записать в 32-битом стандарте IEEE754.
Решение.
Представление двоичного числа с плавающей точкой в экспоненциальном нормализованном виде.
Сдвинем число на 2 разрядов вправо. В результате мы получили основные составляющие экспоненциального нормализованного двоичного числа:
Мантисса M=1.011
Экспонента exp2=2
Преобразование двоичного нормализованного числа в 32 битный формат IEEE 754.
Первый бит отводится для обозначения знака числа. Поскольку число положительное, то первый бит равен 0
Следующие 8 бит (с 2-го по 9-й) отведены под экспоненту.
Для определения знака экспоненты, чтобы не вводить ещё один бит знака, добавляют смещение к экспоненте в половину байта +127. Таким образом, наша экспонента: 2 + 127 = 129
Переведем экспоненту в двоичное представление.
Оставшиеся 23 бита отводят для мантиссы. У нормализованной двоичной мантиссы первый бит всегда равен 1, так как число лежит в диапазоне 1 ≤ M 22 *0 + 2 21 *1 + 2 20 *1 + 2 19 *0 + 2 18 *0 + 2 17 *0 + 2 16 *0 + 2 15 *0 + 2 14 *0 + 2 13 *0 + 2 12 *0 + 2 11 *0 + 2 10 *0 + 2 9 *0 + 2 8 *0 + 2 7 *0 + 2 6 *0 + 2 5 *0 + 2 4 *0 + 2 3 *0 + 2 2 *0 + 2 1 *0 + 2 0 *0 = 0 + 2097152 + 1048576 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 = 3145728
В десятичном коде мантисса выражается числом 3145728
В результате число 101.10 представленное в IEEE 754 c одинарной точностью равно 01000000101100000000000000000000.
Переведем в шестнадцатеричное представление.
Разделим исходный код на группы по 4 разряда.
010000001011000000000000000000002 = 0100 0000 1011 0000 0000 0000 0000 0000 2
Получаем число:
0100 0000 1011 0000 0000 0000 0000 0000 2 = 40B0000016

Библиотека материалов

√ Общеобразовательное учреждение
√ Дошкольное образование
√ Конкурсные работы
Все авторы, разместившие материал, могут получить свидетельство о публикации в СМИ

Инвестиции с JetLend

Удобный сервис для инвестора и заемщика. Инвестируйте в лучшие компании малого бизнеса по ставкам от 16,9% до 37,7% годовых.

Онлайн-университет

Профессии с трудоустройством. Наши направления:
√ Программирование и Дизайн
√ Маркетинг и Управление
√ Игры и Мультимедиа

  • Задать вопрос или оставить комментарий
  • Помощь в решении
  • Поиск
  • Поддержать проект

Правила ввода данных

Задать свои вопросы или оставить замечания можно внизу страницы в разделе Disqus .
Можно также оставить заявку на помощь в решении своих задач у наших проверенных партнеров (здесь или здесь).

Поиск

Задать свои вопросы или оставить замечания можно внизу страницы в разделе Disqus .
Можно также оставить заявку на помощь в решении своих задач у наших проверенных партнеров (здесь или здесь).

Перевод числа с плавающей точкой в двоичную систему счисления

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

Отслеживать
26k 4 4 золотых знака 21 21 серебряный знак 36 36 бронзовых знаков
задан 10 окт 2023 в 6:40
Kostya_200808 Kostya_200808
51 4 4 бронзовых знака
как точный ответ связан с двоичным представлением чисел ?
10 окт 2023 в 6:42

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

10 окт 2023 в 6:45
Возможно, вам подойдёт модуль fractions
10 окт 2023 в 6:49

Может тогда представите задачу в общем, а не идею относительно условной математики на двочиных числах? Может вам нужно правильно сравнивать 0.3-0.2==0.1 ?

10 окт 2023 в 6:50

модуль decimal не подойдет? вот справка от GPT. ЭТо точно будет десятичная арифметика с точно наперед заданной точностью. Точнее чем любое двоичное представление числа флоат ). Может — это и есть та библиотека, которую вы делаете? «Всё уже написано до нас» (с)

10 окт 2023 в 7:02

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

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

Ваш пример будет выглядеть так:

(3, -1) - (2, -1) = (1, -1) # (мантисса, порядок) 

Отслеживать
ответ дан 10 окт 2023 в 7:33
4,269 2 2 золотых знака 3 3 серебряных знака 19 19 бронзовых знаков

Ну и правильно. Вы написали print(0.3-0.2) — это же в десятичной системе? Поэтому, чтобы из конечных десятичных дробей не получались бесконечные двоичные (со всеми вытекающими эффектами), и нужно хранить число в экспоненциальной форме с основание 10, а не 2, как это в float & double.

10 окт 2023 в 15:31

Не путайте машинное представление числа и основание экспоненциальной формы представления. Машинное представление у нас двоичное, что бы там не было наверху, даже символы. А вот при преобразовании из c10*10^b10 в c2*2^b2 как раз и происходят такие беды, когда 0.3-0.2!=0.1 . Поэтому оставайтесь в c10*10^b10 , где c10 и b10 — это целые числа (машинно они будут в двоичном виде, как и всё остальное). Почитайте ru.wikipedia.org/wiki/IEEE_754-2008.

Разбираемся в числах с плавающей точкой (часть 0)

Здравствуйте, хабровчане. Я давно увлекаюсь темой регистров с плавающей точкой. Меня всегда волновало то, как происходит вывод на экран и т.д. Помню, давным-давно в универе реализовывал свой класс чисел с плавающей точкой, состоящих из 512 бит. Единственное, что я не мог никак реализовать — это вывод на экран.

Как только у меня появилось свободное время, я взялся за старое. Завел себе тетрадку и пошло-поехало. Хотелось додуматься до всего самому, лишь иногда заглядывая в стандарт IEEE 754.
И вот что из всего этого вышло. Интересующихся прошу под кат.

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

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

В сегодняшней статье для примера я буду использовать 32-битные регистры. Числа с двойной точностью (64-битные) работают абсолютно по той же логике.

Сначала поговорим о том, как хранятся числа с плавающей точкой. Старший 31 бит у нас знаковый. Единичка значит, что число отрицательное, а ноль, соответственно наоборот. Далее идут 8 бит экспоненты. Эти 8 битов представляют из себя обычное беззнаковое число. И в самом конце идут 23 бита мантиссы. Для удобства будем обозначать знак как S, экспоненту как E, а мантиссу, как ни странно, M.

Получаем общую формулу

У мантиссы принято считать один неявный единичный бит. То есть мантисса будет представлять из себя 24 бита, но так как старший 23-й бит всегда единица, то его можно не записывать. Таким образом это «ограничение» будет давать нам единственность представления любого числа.

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

Давайте попробуем показать это на наглядном примере:

Представим число 3.625 в двоичном виде. Поначалу разобьем это число на степени двойки.

Степень старшей двойки равна единице. E – 127 = 1. E = 128.

0 1000000 11010000000000000000000

Вот и все наше число.

Попробуем также и в обратную сторону. Пусть у нас есть 32 бита, произвольные 32 бита.

0 10000100 (1)11011100101000000000000

В скобочках указан тот самый неявный старший бит.

Сначала вычислим экспоненту. E = 132. Соответственно степень старшей двойки будет равна 5. Итого имеем следующее число:

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

Для удобной конвертации я накидал небольшую программу на языке C.

#include union IntFloat < unsigned int integerValue; float floatValue; >; void printBits(unsigned int x) < int i; for (i = 31; i >= 0; i--) < if ((x & ((unsigned int)1 else < printf("0"); >if (i == 31) < printf(" "); >if (i == 23) < printf(" "); >> printf("\n"); > int main()

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

Можно выразиться иначе. Два соседних числа с плавающей точкой будут отличаться на 2 ^ (E — 127 — 23). То есть на разницу, равную значению младшего бита.

В качестве доказательства можете поменять main в коде и скомпилировать еще раз.

union IntFloat b0, b1, b2; b0.floatValue = 59.578125F; b1.integerValue = b0.integerValue + 1; b2.floatValue = b1.floatValue - b0.floatValue; printBits(b0.integerValue); printBits(b1.integerValue); printBits(b2.integerValue); printf("%f\n", b0.floatValue); printf("%f\n", b1.floatValue); printf("%f\n", b2.floatValue); short exp1 = 0b10000100; short exp2 =0b01101101; /* Крайний случай, когда вся мантиса состоит из единиц */ b0.integerValue = 0b01000010011111111111111111111111; b1.integerValue = b0.integerValue + 1; b2.floatValue = b1.floatValue - b0.floatValue; printBits(b0.integerValue); printBits(b1.integerValue); printBits(b2.integerValue); printf("%f\n", b0.floatValue); printf("%f\n", b1.floatValue); printf("%f\n", b2.floatValue); /* Значения экспонент */ printf("%d %d\n", exp1, exp2); 

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

P.S.: Я понимаю, что я не затронул тему денормализованных чисел и т.д. Просто не хотелось очень сильно грузить статью, да и эту информацию можно легко найти в стандарте IEEE 754 практически в самом начале.

Наглядное объяснение чисел с плавающей запятой

image

В начале 90-х создание трёхмерного игрового движка означало, что вы заставите машину выполнять почти не свойственные ей задачи. Персональные компьютеры того времени предназначались для запуска текстовых процессоров и электронных таблиц, а не для 3D-вычислений с частотой 70 кадров в секунду. Серьёзным препятствием стало то, что, несмотря на свою мощь, ЦП не имел аппаратного устройства для вычислений с плавающей запятой. У программистов было только АЛУ, перемалывающее целые числа.

При написании книги Game Engine Black Book: Wolfenstein 3D я хотел наглядно показать, насколько велики были проблемы при работе без плавающей запятой. Мои попытки разобраться в числах с плавающей запятой при помощи каноничных статей мозг воспринимал в штыки. Я начал искать другой способ. Что-нибудь, далёкое от и их загадочных экспонент с мантиссами. Может быть, в виде рисунка, потому что их мой мозг воспринимает проще.

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

Как обычно объясняют числа с плавающей запятой

Цитирую Дэвида Голдберта (David Goldbert):

Для многих людей арифметика с плавающей запятой кажется каким-то тайным знанием.

Полностью с ним согласен. Однако важно понимать принципы её работы, чтобы полностью осознать её полезность при программировании 3D-движка. В языке C значения с плавающей запятой — это 32-битные контейнеры, соответствующие стандарту IEEE 754. Они предназначены для хранения и выполнения операций над аппроксимациями вещественных чисел. Пока я видел только такое их объяснение. 32 бита разделены на три части:

  • S (1 бит) для хранения знака
  • E (8 бит) для экспоненты
  • M (23 бита) для мантиссы

Внутренности числа с плавающей запятой.

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

Пока всё нормально. Пойдём дальше. Способ интерпретации чисел обычно объясняется с помощью такой формулы:

Именно это объяснение чисел с плавающей запятой все ненавидят.

И здесь я обычно начинаю терять терпение. Возможно, у меня аллергия на математическую нотацию, но когда я это читаю, в моём мозгу ничего не «щёлкает». Такое объяснение похоже на способ рисования совы:

Другой способ объяснения

Хоть это изложение и верно, такой способ объяснения чисел с плавающей запятой обычно не даёт нам никакого понимания. Я виню эту ужасную запись в том, что она разочаровала тысячи программистов, испугала их до такой степени, что они больше никогда не пытались понять, как же на самом деле работают вычисления с плавающей запятой. К счастью, их можно объяснить иначе. Воспринимайте экспоненту как окно (Window) или интервал между двумя соседними целыми степенями двойки. Мантиссу воспринимайте как смещение (Offset) в этом окне.

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

Окно сообщает нам, между какими двумя последовательными степенями двойки будет число: [0,1], [1,2], [2,4], [4,8] и так далее (вплоть до [,]. Смещение разделяет окно на сегментов. С помощью окна и смещения можно аппроксимировать число. Окно — это отличный механизм защиты от выхода за границы. Достигнув максимума в окне (например, в [2,4]), можно «переплыть» вправо и представить число в пределах следующего окна (например, [4,8]). Ценой этого будет только небольшое снижение точности, потому что окно становится в два раза больше.

Викторина: сколько точности теряется, когда окно закрывает больший интервал? Давайте возьмём пример с окном [0,1], в котором 8388608 смещений накладываются на интервал размером 1, что даёт нам точность . В окне [2048,4096] 8388608 смещений накладываются на интервал , что даёт нам точность .

На рисунке ниже показано, как кодируется число 6,1. Окно должно начинаться с 4 и заканчиваться следующей степенью двойки, т.е. 8. Смещение находится примерно посередине окна.

Значение 6,1 аппроксимированное с помощью числа с плавающей запятой.

Давайте возьмём ещё один пример с подробным вычислением представлением в виде числа с плавающей точкой хорошо известного всем нам значения: 3,14.

  • Число 3,14 положительно .
  • Число 3,14 находится между степенями двойки 2 и 4, то есть окно числа с плавающей запятой должно начинаться с (см. формулу, где окно — это ).
  • Наконец, есть смещений, которыми можно выразить расположение 3,14 внутри интервала [2-4]. Оно находится в внутри интервала, что даёт нам смещение
  • S = 0 = 0b
  • E = 128 = 10000000b
  • M = 4781507 = 10010001111010111000011b

Двоичное представление с плавающей точкой числа 3,14.

То есть значение 3,14 аппроксимируется как 3,1400001049041748046875.

Соответствующее значение в непонятной формуле:

И, наконец, графическое представление с окном и смещением:

Окно и смещение числа 3,14.

Интересный факт: если модули операций с плавающей запятой были такими медленными, почему в языке C в результате использовали типы float и double? Ведь в машине, на которой изобретался язык (PDP-11), не было модуля операций с плавающей запятой! Дело в том, что производитель (DEC) пообещал Деннису Ритчи и Кену Томпсону, что в следующей модели он будет. Они были любителями астрономии и решили добавить в язык эти два типа.

Интересный факт: те, кому в 1991 году действительно нужен был аппаратный модуль операций с плавающей запятой, могли его купить. Единственными, кому он мог понадобиться в то время, были учёные (по крайней мере, так Intel понимала потребности рынка). На рынке они позиционировались как «математические сопроцессоры». Их производительность была средней, а цена огромной (200 долларов 1993 года — это 350 долларов в 2016 году.). В результате уровень продаж оказался посредственным.

Надеюсь, статья была вам полезна!

  • floating point
  • числа с плавающей точкой/запятой
  • экспонента
  • мантисса

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *