Что происходит с лишними байтами double при сравнении с меньшим по размеру float?

@Mimik_fc7 · Регистрация: 26.01.2016

Author24 — интернет-сервис помощи студентам

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

итак немного теории, все мы знаем, что float это 4 байта, а double 8
из этого следуя мы понимаем, что присваивая значение:

float a = 1.0;
в памяти у нас занимаются 4 байта, и по идее там 1.000000 (6 знаков после запятой)

с double соответственно.

а теперь магический вопрос:

C++

int main() 
{ 
float a = (float)44.47647f; 
double b = (double)44.476470947265625;
if((float)a == (double)b)
{ 
printf("equals \n"); 
} 
if((double)b > (double)a) 
{
 printf(" bigger\n"); 
} 
}

внимание вопрос, какого X=>Y ???

@Mirmik · 06.12.2017, 17:01

Если коротко, то потому, что

C++

1	(float)a != (double)a

П.С. Я тут чушь написал.

@Mimik_fc7 · 06.12.2017, 17:02 **[ТС]**

Сообщение от Mirmik

Если коротко, то потому, что

если вы скомпилите, то эти числа РАВНЫ

@Mirmik · 06.12.2017, 17:02

П.С. У меня выводит только equals

@Mimik_fc7 · 06.12.2017, 17:12 **[ТС]**

Сообщение от Mirmik

П.С. У меня выводит только equals

это и значит что они равны, но какого ?

Добавлено через 6 минут
да, похоже надо уточнить. Вопрос в том, почему они равны?

@Mirmik · 06.12.2017, 17:13

Опять же, если кратко 44.47647f не имеет точного представления в float выражении. Поэтому компилятор вместо него подставляет ближайшее, оладающее таким представлением. То есть, числа, изначально то как раз были равны.

@Mimik_fc7 · 06.12.2017, 17:16 **[ТС]**

Сообщение от Mirmik

Опять же, если кратко 44.47647f не имеет точного представления в float выражении

в смысле не имеет точного представления? куда точнее? скастуйте а к double результат один они равны о_О

@Mirmik · 06.12.2017, 17:18

http://rextester.com/SPDYU56709

Добавлено через 1 минуту
Вы не сможете найти такую комбинацию битов в объекте типа float, чтобы результат его интерпретации оказался вточности равен 44.47647. Довольно типичная проблема при переходе между системами счисления.

@Mimik_fc7 · 06.12.2017, 17:55 **[ТС]**

Сообщение от Mirmik

Вы не сможете найти такую комбинацию битов в объекте типа float,

да я и не спорю, но у нас значение числа в 4х байтах не может быть равно числу в 8 байтах, и уж темболее заполненным.
и я никак не возьму в толк, почему при касте влота в дабл, я получаю то-же значение, хотя поидее там должны быть нули.

@Mirmik · 06.12.2017, 18:29

C++

#include <gxx/debug/dprint.h>
#include <iostream>
#include <iomanip>
 
int main() {
    std::cout << std::setprecision(20) << 44.476470947265625 << std::endl;
    std::cout << std::setprecision(20) << 44.47647f << std::endl;
 
    dprhexln(44.476470947265625);
    dprhexln((double)44.47647f);    
    dprbinln(44.476470947265625);
    dprbinln((double)44.47647f);    
 
    dprhexln((float)44.476470947265625);
    dprhexln(44.47647f);
    dprbinln((float)44.476470947265625);
    dprbinln(44.47647f);
 
    /*
        44.476470947265625
        44.476470947265625
 
        40463CFD00000000
        40463CFD00000000
        0100000001000110001111001111110100000000000000000000000000000000
        0100000001000110001111001111110100000000000000000000000000000000
 
        4231E7E8
        4231E7E8
        01000010001100011110011111101000
        01000010001100011110011111101000
    */
}

Нули то как раз и на месте.

@TRam_ · 06.12.2017, 18:31

но у нас значение числа в 4х байтах не может быть равно числу в 8 байтах, и уж темболее заполненным.
и я никак не возьму в толк, почему при касте влота в дабл, я получаю то-же значение, хотя поидее там должны быть нули

Сделай вот так:

C++

1	a == (reinterpret_cast<float >(&b))

получишь сравнение 4 байтов float с первыми 4мя байтами double.

А чтоб "по идее там должны быть нули" - сделай вот так:

C++

float a = (float)44.47647f; 
double a2 = 0;
memcpy(&a2, &a, sizeof(float));
double b = (double)44.476470947265625;
if(a2 == b)
{
}

@Mirmik · 06.12.2017, 18:34

Проблема в том, что вы думаете в десятичной системе счисления. Числа, записанные в десятичной системе счисления не всегда красиво выглядят в двоичной и наоборот.

Как вам, например, (double)0.9:
0011111111101100110011001100110011001100110011001100110011001101

@TRam_ · 06.12.2017, 18:35

Только я уверен что ни в *(reinterpret_cast<float *>(&b)), ни в a2 никакого значения наподобие 44.47647 не будет. Потому что https://ru.wikipedia.org/wiki/... й_точности vs https://ru.wikipedia.org/wiki/... й_точности - имеют ну совершенно разное разбиение по битам.

@Mirmik · 06.12.2017, 18:55

При сранении бинарного представления надо помнить, что мантиса double сдвинута относительно float, а также не забыть про little endian

@Rius · 06.12.2017, 19:51

Сообщение от Mimik_fc7

Вопрос в том, почему они равны?

Просто так совпало. Вы выбрали числа до и после приведения типа.

Что происходит с лишними байтами double при сравнении с меньшим по размеру float?

Проверить двоичное и 16-ричное представление можно здесь: https://babbage.cs.qc.cuny.edu... cimal.html

Никогда не сравнивайте числа с плавающей точкой операцией == или !=. Возможно даже вот такое: https://www.cyberforum.ru/blog... g4674.html

@Mimik_fc7 · 07.12.2017, 08:54 **[ТС]**

Сообщение от TRam_

А чтоб "по идее там должны быть нули" - сделай вот так:

и они будут равны =)))

@Rius · 07.12.2017, 09:11

Вы вовсе не float с double сравниваете.
Перед сравнением, оба операнда приводятся к одинаковому типу. Точнее один, который float, приводится к double.
При приведении от float к double, 44.4764709 превращается в 44.476470947265625.
Но это число у вас уже есть и, очевидно, получено оно именно таким приведением типа.
Поэтому операнды и в двоичном виде эквивалентны.

Никакой магии.

@Mimik_fc7 · 07.12.2017, 09:19 **[ТС]**

Сообщение от Rius

Вы вовсе не float с double сравниваете

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

@Mirmik · 07.12.2017, 12:17

Я выше приводил представления наших пациентов в бинарном коде:

C++

1
2
3

44.47647f
double 0100000001000110001111001111110100000000000000000000000000000000
float  01000010001100011110011111101000

Посмотрим подробнее:

C++

1
2
3

знак    экспонента          мантиса
0       10000000100        0110001111001111110100000000000000000000000000000000
0       10000100           01100011110011111101000

Как видите экспоненты записываются в смещенном коде (они равны).
Мантисы задают дробную часть и также равны.

@Mirmik techpriest 634 / 213 / 57 Регистрация: 27.02.2014 Сообщений: 1,180
	06.12.2017, 18:55	14
	При сранении бинарного представления надо помнить, что мантиса double сдвинута относительно float, а также не забыть про little endian 0

@Rius 10563 / 6487 / 1506 Регистрация: 25.05.2015 Сообщений: 19,654 Записей в блоге: 14
	06.12.2017, 19:51	15
	Сообщение от Mimik_fc7 Вопрос в том, почему они равны? Просто так совпало. Вы выбрали числа до и после приведения типа. Проверить двоичное и 16-ричное представление можно здесь: https://babbage.cs.qc.cuny.edu... cimal.html Никогда не сравнивайте числа с плавающей точкой операцией == или !=. Возможно даже вот такое: https://www.cyberforum.ru/blog... g4674.html 0

@Mimik_fc7 0 / 0 / 0 Регистрация: 26.01.2016 Сообщений: 45
	06.12.2017, 17:02 [ТС]	3
	Сообщение от Mirmik Если коротко, то потому, что если вы скомпилите, то эти числа РАВНЫ 0

@Mirmik techpriest 634 / 213 / 57 Регистрация: 27.02.2014 Сообщений: 1,180
	06.12.2017, 17:02	4
	П.С. У меня выводит только equals 0

@Mimik_fc7 0 / 0 / 0 Регистрация: 26.01.2016 Сообщений: 45
	06.12.2017, 17:12 [ТС]	5
	Сообщение от Mirmik П.С. У меня выводит только equals это и значит что они равны, но какого ? Добавлено через 6 минут да, похоже надо уточнить. Вопрос в том, почему они равны? 0

@Mirmik techpriest 634 / 213 / 57 Регистрация: 27.02.2014 Сообщений: 1,180
	06.12.2017, 17:13	6
	Опять же, если кратко 44.47647f не имеет точного представления в float выражении. Поэтому компилятор вместо него подставляет ближайшее, оладающее таким представлением. То есть, числа, изначально то как раз были равны. 0

@Mimik_fc7 0 / 0 / 0 Регистрация: 26.01.2016 Сообщений: 45
	06.12.2017, 17:16 [ТС]	7
	Сообщение от Mirmik Опять же, если кратко 44.47647f не имеет точного представления в float выражении в смысле не имеет точного представления? куда точнее? скастуйте а к double результат один они равны о_О 0

@Mirmik techpriest 634 / 213 / 57 Регистрация: 27.02.2014 Сообщений: 1,180
	06.12.2017, 17:18	8
	http://rextester.com/SPDYU56709 Добавлено через 1 минуту Вы не сможете найти такую комбинацию битов в объекте типа float, чтобы результат его интерпретации оказался вточности равен 44.47647. Довольно типичная проблема при переходе между системами счисления. 0

@Mimik_fc7 0 / 0 / 0 Регистрация: 26.01.2016 Сообщений: 45
	06.12.2017, 17:55 [ТС]	9
	Сообщение от Mirmik Вы не сможете найти такую комбинацию битов в объекте типа float, да я и не спорю, но у нас значение числа в 4х байтах не может быть равно числу в 8 байтах, и уж темболее заполненным. и я никак не возьму в толк, почему при касте влота в дабл, я получаю то-же значение, хотя поидее там должны быть нули. 0

@Mirmik techpriest 634 / 213 / 57 Регистрация: 27.02.2014 Сообщений: 1,180
	06.12.2017, 18:34	12
	Проблема в том, что вы думаете в десятичной системе счисления. Числа, записанные в десятичной системе счисления не всегда красиво выглядят в двоичной и наоборот. Как вам, например, (double)0.9: 0011111111101100110011001100110011001100110011001100110011001101 0

@TRam_ зомбяк 1584 / 1218 / 345 Регистрация: 14.05.2017 Сообщений: 3,939
	06.12.2017, 18:35	13
	Только я уверен что ни в `(reinterpret_cast<float >(&b))`, ни в a2 никакого значения наподобие 44.47647 не будет. Потому что https://ru.wikipedia.org/wiki/... й_точности vs https://ru.wikipedia.org/wiki/... й_точности - имеют ну совершенно разное разбиение по битам. 0

@Mimik_fc7 0 / 0 / 0 Регистрация: 26.01.2016 Сообщений: 45
	07.12.2017, 08:54 [ТС]	16
	Сообщение от TRam_ А чтоб "по идее там должны быть нули" - сделай вот так: и они будут равны =))) 0

@Rius 10563 / 6487 / 1506 Регистрация: 25.05.2015 Сообщений: 19,654 Записей в блоге: 14
	07.12.2017, 09:11	17
	Вы вовсе не float с double сравниваете. Перед сравнением, оба операнда приводятся к одинаковому типу. Точнее один, который float, приводится к double. При приведении от float к double, 44.4764709 превращается в 44.476470947265625. Но это число у вас уже есть и, очевидно, получено оно именно таким приведением типа. Поэтому операнды и в двоичном виде эквивалентны. Никакой магии. 0

@Mimik_fc7 0 / 0 / 0 Регистрация: 26.01.2016 Сообщений: 45
	07.12.2017, 09:19 [ТС]	18
	Сообщение от Rius Вы вовсе не float с double сравниваете Да, я понимаю, что при сравнении компилятор сам кастит типы, тут дело в другом, я почитал всю инфу что накидали, немного прояснилось, но самое главное, ответ крылся в кастах, самое интересное, это если преобразовать оба числа в HEX то они будут разные =) и даже битовые виды абсолютно разные. я помню, что у компилятора, есть настройка строгой типизации, похоже надо бы ее включить. 0