Случай простой double d = 0.0; if (d == 0.0) cout << 1;

нет

Почему ? Их компилятор во врнмя сборки переводит в байт код

double d = 0.0 может побайтово разное в разных случаях?

бывает плюс ноль, а може быть минус ноль

и они побитово отличаются

И побобайтово сравнивает. Поскольку это далал один и тот же компилятор - то оно будет одно и тоже.

Почему ? Их компилятор во врнмя сборки переводит в байт код

в байт код! ништяк

Ну я имею ввиду - битовое представление

Ну я имею ввиду - битовое представление

бит код

double d() { return 0.0; } может вернуть минус ноль?

А вот если эти числа получены при вычислениях - то тут уже будет погрешность.

И та, в 16 знаке

0.0 это ноль а не минус ноль

в байт код! ништяк

но в байт-код тоже переводит, правда лишь только для внутренних целей при трансляции

Случай простой double d = 0.0; if (d == 0.0) cout << 1;

о равенстве флоатов можно говорить только с точность до

но в байт-код тоже переводит, правда лишь только для внутренних целей при трансляции

ллвм только в bitcode переводит

и тот на самом деле сериализация IR!

Я не спорю что я могу ошибаться. Но я собственными руками переводил строку в double. Без каких либо библиотек.

Случай простой double d = 0.0; if (d == 0.0) cout << 1;

Это сработает, если именно везде будет константа 0.0

золотые руки

Я не спорю что я могу ошибаться. Но я собственными руками переводил строку в double. Без каких либо библиотек.

поставлю в светлице твою икону и буду молиться пожалуй

И это работало быстрее чем itof, std stod

Я знаю, что нельзя сравнивать даблы друг с другом, но с 0.0 можно?

Если же хочешь получить 0 в вычислениях, то сравнение не совсем корректно

Если же хочешь получить 0 в вычислениях, то сравнение не совсем корректно

+

Я знаю, что нельзя сравнивать даблы друг с другом, но с 0.0 можно?

Я знаю, что нельзя сравнивать даблы друг с другом, но с 0.0 можно?

0.0 тоже дабл, следовательно...

Ибо 0.0000001 это ошибка ибо не ноль

Я знаю, что нельзя сравнивать даблы друг с другом, но с 0.0 можно?

с точностью до

Еще фишки есть с nan

Так, что дабла не бывает т пустого никогда?

Константа 0 это совсем 0

Например double a = nan

Так, что дабла не бывает т пустого никогда?

пустой бывает, это NaN

OK

бывает еще полный дабл, это Inf

a == nan

Выдаст false :)

Константа 0 это совсем 0

(в точности double)

Перефразирую

Таким образом работает isnan - return !(a == nan)

bool b = 0.0 == 0.0 всегда true?

Да

Почему ? Их компилятор во врнмя сборки переводит в байт код

Чисто теоретическая возможность: Была весёлая фишка. какой-то из процессоров при работе с float переводил их сначала в double делал вычисления, потом конверировал обратно. И кажется порой он мог перевоодить только один операндов. Подозреваю что могут быть процессоры, которые делают похожую чушь для double и long double, и у них такие приведения могут лажануть

То есть константа 0.0 всегда одинакова в бинарном виде?

С другой стороны, такой проц будет жуткой упячкой... Мало кто будет им пользоваться и его выкинут на свалку :)

То есть константа 0.0 всегда одинакова в бинарном виде?

ну если она 0.0f и 0.0f то да

То есть константа 0.0 всегда одинакова в бинарном виде?

0 он и в double 0

С другой стороны, такой проц будет жуткой упячкой... Мало кто будет им пользоваться и его выкинут на свалку :)

Явно не в духе интела :)

ну если она 0.0f и 0.0f то да

Ну 0.0 и 0.0 тоже)

Только там знаков больше

Явно не в духе интела :)

Ага, совсем не в духе Itanium

То есть с 0.0 всё-таки можно сравнивать?))

Ага, совсем не в духе Itanium

Но даже если так, сначала перед ввчмслениями double надо в регисьры перевести.

Но даже если так, сначала перед ввчмслениями double надо в регисьры перевести.

регистры фпу же

И вот этот перевод будет одинаков

а они там широооокие нынче

Но даже если так, сначала перед ввчмслениями double надо в регисьры перевести.

там я читал регистры под дабл были)

регистры фпу обычно 80 бит

Это в книге у Курта Гантерота написано было)

То есть с 0.0 всё-таки можно сравнивать?))

тебе надо удостоверится, что это именно твой иницилизатор? заведи константу const double ZERO = 0;

То есть с 0.0 всё-таки можно сравнивать?))

Можно, если то, что сравниваешь, равняется константе 0.0, а не получилось в вычислениях (это должно нереально повезти)

И даже если он будет делать какие либо вычисления с теми же битами, резулььат должен бы быть один

тебе надо удостоверится, что это именно твой иницилизатор? заведи константу const double ZERO = 0;

и еще одну константу const double EPS :) с нужной точностью

тогда double a = ZERO, b = ZERO; assert(a == b);

Можно, если то, что сравниваешь, равняется константе 0.0, а не получилось в вычислениях (это должно нереально повезти)

Да я сравниваю то что получилось с константой 0.0

Низя

Разве что дельту сравнивать

Да я сравниваю то что получилось с константой 0.0

а 0.0 у тебя float, double или long double?

delta < 1e-5 например

Низя

Нельзя потому что результат может быть не побайтово нулём? Главное что правая часть всегда правильный ноль. Пусть вернёт false

Еще есть методы коменсации погрешности - например Шевчука

Нельзя потому что результат может быть не побайтово нулём? Главное что правая часть всегда правильный ноль. Пусть вернёт false

Именно

Мягко говоря дабл из 64 бит превращается по точгости в 128

То есть false при любой погрешности

А флоат в дабл по точности

То есть false при любой погрешности

Ага

Это меня устраивает

При любой больше точности double

https://godbolt.org/g/LscNcY

Было бы обидно, если бы результат вычислений был "правильным нулём", а 0.0 был бы неправильным...