Я раньше думал, что можно просто 4 нулевых байта добавить и будет норм, а оказалось нихуя. Единственное, что я понял, что первый бит в записи означает знак (0=+, 1=-), остальное какая-то ебаная магия, какие-то непонятные цифры, хз че происходит помогите
Язык какой?
Мне нужно не для конкретного языка, а в общем алгоритм, что как делать, какие математические операции делать.
У тебя же на оппике все битослесарство и нарисовано, никакой там нет магии.
https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D0%BE%D0%B4%D0%B8%D0%BD%D0%B0%D1%80%D0%BD%D0%BE%D0%B9_%D1%82%D0%BE%D1%87%D0%BD%D0%BE%D1%81%D1%82%D0%B8
https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D0%B4%D0%B2%D0%BE%D0%B9%D0%BD%D0%BE%D0%B9_%D1%82%D0%BE%D1%87%D0%BD%D0%BE%D1%81%D1%82%D0%B8
Ну, к экспоненте нули вперёд, к мантиссе - нули назад. Вроде так. А нахуя, если компьютер это делает аппаратно?
>А нахуя, если компьютер это делает аппаратно?
У меня он делает какую-то хуйню.
Например есть float 1.73
Я перевожу в double и получаю 1.7299999935683924 вроде такой хуйни.
float x = 1;
double y = (double)x;
Скомпилируй на разных архитектурах и посмотри дизассемблером как компилятор это делает.
>Например есть float 1.73
Не бывает такого float. Разберись, что это за тип данных сначала.
че несешь такое
Так и должно быть. В рамках погрешности флоата. Там вообще на разных архитектурах может немного по разному давать результат.
> В отличие от чисел с фиксированной запятой, сетка чисел, которые способна отобразить арифметика с плавающей запятой, неравномерна: она более густая для чисел с малыми порядками и более редкая — для чисел с большими порядками.
ДА ЧТ ЗА НАРКОМАНИЯ БЛЯДЬ?
Как одно число превращается в другое? Вот было у меня 2 яблока, я перекинул его в другую корзину и стало 1 яблоко. Куда еще одно делось?
А если тебе изначально приходит флоат извне программы?
Че за сетка блядь
float это же не целые числа с запятой.
или я чего то не понимаю? что тебе мешает блять взять табоицу байтов(или как ткм она называется), и перевести блять это в байты?
Ещё одно обозначает знак, представь запись числа один: 01, +1, -1. Аж целых три варианта для двух символов, неизвестно какой реализовали у тебя.
Конвертируй в строку, а потом парси ее в дабл, делов то.
мимо-веб-программист
пиздец рыгнул с тебя
мимо-эмбеддед-программист
Это сработало бы для целочисленных типов, но для чисел с плавающей точкой дополнительные биты не только расширяют диапазон, но и увеличивают "точность" (т.е. кол-во знаков после запятой)
что за примитивизм, округляешь до целой и профит
мимо индус 300к/наносек
Так че сделать то надо, чтобы перевести из одного в другое? И чтобы ничего никуда не проебывалось.
округлять до запятой и копировать пару чисел после
> эмбеддед
Нахуя твоим мк вообще обрабатывать шо-то больше инта?
Кому вообще эти плавающие точки нужны кроме учёных и астрономов? Игры/видео/аудио/нейросети прекрасно работают на целочисленной арифметике.
дохуя чего, показания датчиков и тд.
>Игры/видео/аудио/нейросети прекрасно работают на целочисленной арифметике.
Ок, зумер.
А более цивилизованного способа нет? хоть и выглядит работоспособным
Что не так? Банки исключительно на целых производят вычисления. НИкаких плавающих и подобных. Не?
>>254728705
Домножить единицу на 1000 чтоб без запятыхоаботать не судьба?
мимо индус 300к/наносек
Есть наверняка, но зачем если мощность позволяет.
я смотрю у тебя дохуя лишних процессорных тактов, пидор
Главное чтоб работало, а на выходе нарисуешь запятые и будет даже быстрее чем если бы считал как обычно.
>Главное чтоб работало
Когда нужно несколько лямов операций в секунду, работать перестанет.
Блядь, в чем сложность-то, выше уже есть ссылки на википедию, где половина кода написана:
Рабираешь побитовыми операциями свой 32-битный флоат на знак/порядок/мантиссу, собираешь из них 64-битный double.
С чего бы, не целочисленные расчёты менее естественны, так что зависнет от запятых, а не от больших положительных.
>собираешь из них 64-битный double.
Как, блядь? Я понимаю, где знак-порядок-мантисса, но как их превратить в 64-битный формат непонятно нихуя.
Там в википедии есть "Общий шаблон для побитового доступа" (для флоата), тебе нужно понять, как это работает и написать такой же для дабла.
>"Общий шаблон для побитового доступа" (для флоата), тебе нужно понять, как это работает
Ебаный рот, я в курсе, что такое побитовый доступ.
Вот тебе на пикрелейтеде, одно и то же число.
1) показатель для Float 10000111;
2) показатель для Double 10000000111;
Каким ебаным хуем первое превращается во второе?
А этого можно "избежать", если сначала кастить в строку. Знаешь почему так происходит? Потому что изначально флоат хранит больше данных, чем отображает. То есть потери информации не происходит.
Перебираешь справа налево, если нулики до конца -- тыришь циферку и пишешь её в строку, затем достаёшь свой дабл и тыкаешь её туда, не забывая нарисовать запятую.
>А этого можно "избежать", если сначала кастить в строку.
И че мне потом строку ковырять? Это же максимум уебанство.
>Каким ебаным хуем первое превращается во второе?
Ну все же на твоей картинке расписано:
135-127 == 1031-1023
Хорошь тупить.
>Перебираешь справа налево, если нулики до конца
Чего? Если нулики до конца, то число = 0, до какого конца то?
> тыришь циферку и пишешь её в строку
Какую циферку? Куда её писать, о чем ты вообще.
Касти встроенными средствами языка, ещё раз говорю. Если отображаешь в гуй, то используй округление, чтоб красивее было.
Что это за цифры? Откуда они берутся? Блять проще никак что ли?
>то используй округление
Не работает округление, я хз почему. Пишет всё это говно после запятой, сколько бы я не округлял.
Берёшь вбиваешь в гугл свой язык программирования и гуглишь округление. Не может такого быть, чтобы округление не работало.
Проверку сделать не судьба? Куда хочешь туда и пишешь, твоя задача превратить входные данные в удобные для дабла символы.
Умножаешь на 100 и переписываешь число без запятой, потом две цифры отделяешь на выводе. Что как маленький.
Округление работает только если я представляю число в десятичной записи типа 0.0033. А если в экспоненциальной, то пишет хуету вроде 3.299993584383573e-3. Мне надо именно экспоненциальная форма.
135 = 10000111 экспонета флоата, меряется от 127 (0x7F), т.е. +8
1031 = 10000000111 экспонета дабла, меряется от 1023 (0x3FF), т.е., ВНЕЗАПНО, снова +8
Это крайне долбоёбская задача. В таком случае советую округлять через форматирование строк. Но для вычислений округление уже не использовать, потому что ну ёбаны в рот, какого хуя-то блядь.
>хочу в виде чуши
>вижу чушь
>удивляюсь
Так ему сразу сказали делать через строки, а он хочет не решение получить, а перед кем-то отчитаться видимо. В реальности этим не занимаются, главное чтоб работало, а как - не твоя проблема.
Это не я хочу, а так надо по условию задачи.
>>254731232
Как это округлять через форматирование строк? Ты имеешь в виду просто отбрасывать лишнее или что? В любом случае мне надо производить расчеты с числом, значит придется обратно переводить, это уже потеря точности.
Нет, это ты хочешь и всё. Была бы задача - ты бы решил просто представив всё как целое число, в меру требуемой точности, а на выходе дорисовал бы что надо. Заказчик всё равно не увидит, а результат будет. А вот если это понты всякие, вроде задачи для учебника, то тут надо смотреть мануалы и отгадывать что именно от тебя хотят увидеть.
Иногда важно знать, как работает, но выводить в гуй значения в не человекочитаемых форматах - чистый долбоебизм.
>>254731573
>Ты имеешь в виду просто отбрасывать лишнее или что?
Примерно так округление и работает.
>В любом случае мне надо производить расчеты с числом
Ты тупой? Ты тупой. Зачем тебе проводить расчёты с округлённым числом, где информация в любом случае будет теряться, когда у тебя есть оригинальное число. Не округлённое. В гуй выводи хоть залупу конскую, хоть строки. Для вычислений это не важно. А вычисления производи над наиболее полными данными.
Читаемый формат делается подстановкой нужных символов в нужном месте, я это говорю как чел который сделал эмулятор машины тьюринга и тайно пользовался ею вместо готовых процедур, ибо весело.
>Нет, это ты хочешь и всё. Была бы задача - ты бы решил просто представив всё как целое число, в меру требуемой точности, а на выходе дорисовал бы что надо. Заказчик всё равно не увидит, а результат будет.
Заказчик хочет увидеть число в экспоненциальной форме, т.е. N x 10^M.
>>254731977
>Примерно так округление и работает.
Че ты несешь? Так работает округление только в меньшую сторону.
>Зачем тебе проводить расчёты с округлённым числом, где информация в любом случае будет теряться, когда у тебя есть оригинальное число.
Оригинальное число хуевое.
Вот например есть число 1e-3, которое поступает в виде флоат 4 байта. Если я перевожу его в дабл, оно превращается в 9.999999353812e-4. Превращение в строку превратит это в явное говно. Мне нужно именно 1e-3, а не 9.9e-4.
Берёшь десятичное написание, тыришь циферки и записываешь так как просят. Если точность не проверяют - можешь ходь рандомный диапазон после запятой задавать.
Почему нет способа цивилизованно сделать без наебалова?
(double) 15
Ну это если примитивы
Он есть, тебе выше объяснили, через юнионы, арифметику и битовые операции, но тебе сложна.
Это и есть цивилизованный способ, может и есть супер-пупер функция чтоб делать так как ты сказал, но внутри может быть та же самая история. Более того скажу - комп именно так и работает, он не воспринимает нашу чушь и считает всё целочисленным, а уже потом расценивает некоторые числа не так как другие. Познай природу компьютера, будь естественным, кодь как индус.
Нихуя он не считает всё целочисленным.
Всё считает, физически у него есть только ничего и единички, а чтоб ты смог увидеть что-то после запятой или с минусом - приходится часть чисел расценивать не как часть числа, а как знаковую и дополнительную области.
Нет, для компьютера есть массивы битов. Это не то же самое, что единички и нолики, нолики и единички - это отображение для людей. Так вот если массив битов, который воспринимается компьютером, как число с плавающей запятой. И расчёты над этими числами выполняются на соответствующих аппаратных блоках, например FP32.
Блять ладно, попробуем еще раз. Вот например число 1e-3:
sign exponent mantissa
+1 1013 1.0000011000100100110111010010111100011010100111111100 (binary)
+1 2^(1013 - 1023) 1.024
+1 0.00097656250000000000 1.024
0.001
+1 степень, это ясно.
степень 1013 - это что? Это в десятичном выражении или как? Откуда это число взялось? Почему основание степени - двойка? Что такое 1.024? Я так понимаю это нужно разложить снизу вверх? Как они 0.001 разложили на это: +1 0.00097656250000000000 1.024?
Внезапно ни запятой, ни массива компьютер не видит. И лишь интерпретируя единички, их наличие в заданном месте, он даёт нам то что мы считаем плавающей запятой.
Нет, для компьютера не существует никаких единичек. Есть только массивы битов.
Оно записывается в двоичной системе, поэтому не всегда возможно записать точное значение. Например, 11.62510 в двоичной представляется как 1011.1012, и соответственно оно может быть записано точно как в double, так и во float. В то же время, например, 1.210 в двоичной системе счисления может быть записано только в виде бесконечной периодической дроби: 0.001100110011...2 = 0.(0011)2. Кроме того, количество цифр после (и перед) запятой конечное, поэтому даже те числа, которые в двоичной системе имеют конечное число цифр после запятой, не всегда могут быть записаны точно даже в long double (10 байт).
Массивы битов это выдуманная людьми условность, так как они не способны смириться с тем что компьютер это супер быстрый Абу который считает всё палочками.
Не такой уж и быстрый. Если его заставить считать именно единичками и ноликами, то будет раз в десять медленнее, чем операции над массивами битов на специализированных вычислительных блоках. Сейчас вот в видимокартах пошла мода на половинную точность, потому что тогда массив битов, приходящих в блок короче и вычислять получается быстрее.
Пойми, вычислительные блоки это Абу с покрашенными палочками: он считает единички, а ты их интерпретируешь не так как Абу. Но реальность такова что это единички, даже если ты завёл для этого отдельного Абу и посадил его в отдельный обезьянник.
>В то же время, например, 1.2 в двоичной системе счисления может быть записано только в виде бесконечной периодической дроби:
Почему нельзя записать 1.10?
На самом нижнем уровне нет никакого абу. Есть только биты.
Потому что это 1.5, чел...
>Кроме того, количество цифр после (и перед) запятой конечное, поэтому даже те числа, которые в двоичной системе имеют конечное число цифр после запятой, не всегда могут быть записаны точно даже в long double (10 байт).
Хуйня какая-то, любое двоичное число переводится в десятичное.
Вот есть же
0 = 0
1 = 1
10 = 2
11 = 3
100 = 4
101 = 5 и так далее. Почему нельзя точно записать?
1.5 это 1.101
Это целые числа. С дробными так нельзя.
> 1e-3
Это десятичная экспоненциальная запись. Один умножить на десять в минус третьей. Сохранить ее без потери точности в двоичной экспоненциальной записи нельзя.
>+1 степень, это ясно.
+1 это знак, положительное
>степень 1013 - это что? Это в десятичном выражении или как?
Это десятичное беззнаковое, просто как если бы биты означали целое неотрицательное число (0-2047). Но показатели бывают отрицательные (-1023 - +1024), поэтому из него надо вычесть 1023 (получится минус десять).
> 0.0009765625
Это два в степени минус десять
> Что такое 1.024
Мантисса.
> Откуда это число взялось?
В момент float x = 1e-3; происходит конверсия.
> Почему основание степени - двойка
Коротко, по стандарту. Стандарт такой потому что так считать эффективнее.
Биты это палочки, единички, которые перебирает Абу из-за того что к нему под хвост поступают электросигналы.
Ты не знаешь, как работают позиционные системы счисления.
1.1012 = 1 20 + 1 2-1 + 0 2-2 + 1 2-3 = 1.62510
>>254734302
Блядь, разметка.
1.1012 = 1 × 20 + 1 × 2-1 + 0 × 2-2 + 1 × 2-3 = 1.62510
Нет никаких палочек. Биты это конденсаторы и транзисторы. Нули и единицы это уже для человека выдумано. Есть только биты.
>+1 это знак, положительное
Да, у меня башка уже кружится от этого гавна
>(получится минус десять)
Почему нам нужно именно минус десять?
>Это два в степени минус десять
Это я понял, только откуда здесь минус десять то высралось.
>Мантисса.
Что мантисса? Мантисса это 1 в числе 1e-3. Что за 1.024?
>Коротко, по стандарту. Стандарт такой потому что так считать эффективнее.
Вообще ничего непонятно.
Единица есть сигнал, нет - нет. Это не бит, а единица, так как комп не умеет читать нули. Но благодаря интерпретации мы можем учитывать отсутствие единиц в определённых местах и так привязываем одни единички - к другим.
И че это такое?
>Сохранить ее без потери точности в двоичной экспоненциальной записи нельзя.
А как же тогда в памяти хранится?
В виде единичек, целочисленных беззнаковых единичек.
Смотри пишу:
1E-3
Опа, как же я это сделал? Ведь по логике сейчас на экране я должен увидеть 1.00000000012489124E-3, но я вижу 1E-3.
> Что мантисса? Мантисса это 1 в числе 1e-3. Что за 1.024?
В десятичной записи этого числа мантисса это 1. В двоичной - 1.024 (а показатель - минус десять).
Просто перевели из десятичной системы счисления в двоичную, потому что по стандарту/определению float и double записываются в двоичной.
В процессе перевода точность потерялась.
>В двоичной - 1.024
Начнем с того, что в двоичной нет "2" и "4".
>>254735043
В исходниках оно хранится текстом:
float x = 1E-3;
После компиляции (и соответственно при выполнении) точность уже потеряна.
Не в двоичной системе счисления, а в двоичной экспоненциальной записи, как на оповых скринах.
>В исходниках оно хранится текстом:
Спрошу по-другому, мне в программу приходит 4 байта, являющихся числом с плавающей точкой Я никак не могу изменить формат получения данных, НЕ текст, а именно 4 байта.
Мне нужно превратить их в 8 байт для обработки.
Ну чел, нельзя просто взять и в двух словах на двачах объяснить, как устроены числа с плавающей запятой. Особенно тому, кто не знает про системы счисления. Продолжай разбираться, гугли, читай всякие статьи на хабре на эту тему. В какой-то момент дойдет. Для начала осознай, что ответа на вопрос, как это сделать, не будет пока ты не поймешь, как это устроено.
Я примерно понял, не могу понять другую вещь, почему нельзя округлить число до определенной точности? Ну то есть если я отбрасываю в мантиссе даже последний бит, то получаю огромное неадекватное число. Как правильно округлять то?
Как именно ты его "отбрасываешь"? Приведи пример.
10010001 например
делаю 10010000
Я имел ввиду, приведи число полностью. Это 8 бит, которые в начале, после знака? Это не мантисса, а показатель степени. Мантисса это последние 23 бита.
>Это не мантисса, а показатель степени. Мантисса это последние 23 бита.
Я знаю, я просто пример привел.
>Я имел ввиду, приведи число полностью.
Ну вот например пикрелейтед.
Последнюю "с" поменял на 0. Мантисса превратилась в огромный пиздец.
Вопрос как именно сделать так, чтобы было 0.001.
Не показатель степени, а порядок, если точнее. Показатель степени у float это порядок (8-битное значение) минус 127.
самофикс
Так а что не так? Это нормально. Ты немного поменял значение мантиссы в хвосте и число стало немного другим: 0.001 ~ 0.000999...
>Вопрос как именно сделать так, чтобы было 0.001.
> Вопрос как именно сделать так, чтобы было 0.001.
Забудь про точность. Этот формат в принципе ее не гарантирует.
И вопрос был не про точность, а про то как округлить. Точность не нужна, нужна нормальная цифра, без 99999999999999999999999999999
Вот смотри, ты хочешь представить в двоичной системе число 1/1000, которое в десятичной системе выражается точно как 0.001 = 1 × 10-3. В двоичной системе счисления это не выражается конечной дробью: 0.00110 = 0.00000110001...2. Поэтому это число просто нельзя представить точно ни в float, ни в double.
Ты врешь, я вижу на экране переменную типа float со значением 1E-3.
Как округлить при выводе, то есть? Это уже совсем про другое вопрос. Изначально ты спрашивал именно про тип float.
Ну да, при выводе она округляется
> Ты врешь
Лол
Каком выводе? Я прямо через отладчик смотрю, там значение 1e-3.
Ну и как же округлить при выводе? Только мне не надо в строку переводить.
Блядь, так он тебе и вывел в читаемом нахуй формате, ебать. Ебаный отладчик округлил ебучую дробь, потому что блядское отклонение очень маленькое, что тебе непонятно?
Тебе же вроде надо было преобразовать float в double, не? Или ты не ОП? Как округлить при выводе - совсем отдельный вопрос. Что конкретно тебе надо сделать?
Если тебе надо преобразовать float в double, тебе не надо ничего округлять. Тебе нужно просто корректно скопировать мантиссу, порядок и знак.
Ну я копирую и получается хуета.
float в double в языке си приводится неявно, это присваивающее приведение, вам не требуется явного преобразования (double)
второе, с вероятностью 95% на современных платформах будет использоваться явная машинная команда преобразования, например под x86-64 это будет ассемблерная команда cvtss2sd, будет задействован сопроцессор - модуль операций с плавающей точкой
Лучше всего вообще ничего не конвертировать, а сразу использовать double. Ну или float, если исходные данные в нём.
но если опу очень хочеться с учебной целью сделать такое приведение руками, то вот подсказка: нужно использовать struct с union внутри для того чтобы получить плоское представление float и double в памяти, а потом уже таким образом получив доступ к внутреннему представлению вещественных чисел, написать алгоритм преобразования ручками
внутреннее представление float и double в x86-64 легко гуглиться, как и алгоритм преобразования
вообще, если подобные задания тебе дают в вузике, то это хороший вуз и хороший препод
Тип с плавающей точкой не может хранить непрерывное множество чисел, поэтому некоторые значения могут быть представлены в нём только как приближения к желаемым. Поэтому, плавающую арифметику категорически нельзя использовать, например, для денежных величин, где погрешность в принципе недопустима.
А если исходные данные в float, нужно преобразовать, обработать и передать в другое место, но уже в double?
Неправильно копируешь, значит. Учти еще, что там бывают особые случаи, когда порядок минимальный (денормализованная форма записи числа) или максимальный (частные случаи: бесконечность, не-число). Разберись подробнее. Вот тебе пример:
29,53125
float
0'10000011'11011000100000000000000
double
0'10000000011'1101100010000000000000000000000000000000000000000000
У double показатель степени = порядок (11 бит) минус 1023
Ты можешь подробно написать какие математические операции ты сделал чтобы получить мантиссу и показатель?
> 29,53125
> float
> 0'10000011'11011000100000000000000
> double
> 0'10000000011'1101100010000000000000000000000000000000000000000000
S = 0 (положительное)
E = 100000112 = 131
0 < E < 255, следовательно число нормализованное (обычное, то есть), значит число имеет вид +-1,M × 2E - 127:
+1,11011000100000000000000 × 2131 - 127 = 1,110110001 × 24 = 11101,100012 = 29,53125
Преобразование в double:
1) копируем 1 бит со знаком
2) следующие 11 бит E' = E - 127 + 1023 = (131 - 127) + 1023 = 4 + 1023 = 1027 = 100000000112
3) мантису копируем как есть, заполняя нулями хвост
Для денормализованных чисел типа float (E = 0) все по-другому, потому что они, в отличие от нормализованных, имеют вид 0,M × 2-126. Денормализованные числа типа double, соответственно: 0,M' × 2-1022. Поэтому денормализованный float придется преобразовать в нормализованный double (E' > 0), который имеет вид 1,M' × 2E' - 1023, то есть эту неявную единичку нужно в таком случае брать в расчет.
>Например есть float 1.73
>Я перевожу в double и получаю 1.7299999935683924 вроде такой хуйни.
- Сколько программистов нужно, чтобы вкрутить лампочку?
- 1.9946938293545, но это приемлемая точность.
>Поэтому, плавающую арифметику категорически нельзя использовать, например, для денежных величин, где погрешность в принципе недопустима.
Раз уж подняли такую тему, как на ЦПП делать арифметику с фиксированной точкой с минимальным количеством костылей?
коллеги по разработке звукового движка кидают в меня тухлыми помидорами за использование uint, который надо сдвигать, но продолжают им пользоваться
покормите зелёного братишку