Существует ли значение x с плавающей запятой, для которого xx == 0 является ложным?
В большинстве случаев я понимаю, что тест сравнения с плавающей запятой должен выполняться с использованием диапазона значений (abs(xy) Я предполагаю, что nan/inf может быть особым случаем, но меня больше интересует, что происходит для простых значений. редактировать: Я рад выбрать ответ, если кто-то может привести ссылку (стандарт IEEE с плавающей запятой)?// can the assertion be triggered?
float x = //?;
assert( x-x == 0 )
6 ответов
Как вы намекали, inf - inf является NaN, который не равен нулю. Так же, NaN - NaN является NaN, Это правда, однако, что для любого конечного числа с плавающей точкой x, x - x == 0.0 (в зависимости от режима округления, результат x - x может быть отрицательный ноль, но отрицательный ноль сравнивается равным 0.0 в арифметике с плавающей точкой).
Изменить: немного сложно дать четкую ссылку на стандарты, потому что это новое свойство правил, изложенных в стандарте IEEE-754. В частности, из требования следует, чтобы операции, определенные в разделе 5, были правильно округлены. Вычитание - это такая операция (Раздел 5.4.1 "Арифметические операции"), и правильно округленный результат x - x является нулем соответствующего знака (раздел 6.3, пункт 3):
Когда сумма двух операндов с противоположными знаками (или разности двух операндов с одинаковыми знаками) равна нулю, знак этой суммы (или разности) должен быть +0 во всех атрибутах направления округления, кроме roundTowardNegative; под этим атрибутом знак точной нулевой суммы (или разности) должен быть -0.
Итак, результат x - x должно быть +/- 0и, следовательно, должны сравниваться равными 0.0 (Раздел 5.11, пункт 2):
Сравнения должны игнорировать знак нуля.
Дальнейшее редактирование: Нельзя сказать, что глючный компилятор не мог вызвать срабатывание этого утверждения. Ваш вопрос неоднозначен; нет конечного числа с плавающей точкой x такой, что x - x == 0 ложно Однако проверяет не тот код, который вы опубликовали; он проверяет, может ли определенное выражение в языке C-стиля иметь ненулевое значение; в частности, на определенных платформах, при определенных (непродуманных) оптимизациях компилятора, два экземпляра переменной x в этом выражении могут иметь разные значения, что приводит к сбою утверждения (особенно если x является результатом некоторого вычисления вместо постоянного представимого значения). Это ошибка в числовой модели на этих платформах, но это не значит, что это не может произойти.
Если представление преобразуется (например, из 64-битного формата памяти в 80-битный формат внутреннего регистра на x86), я ожидаю, что утверждение может сработать при некоторых обстоятельствах.
Да кроме особых случаев x-x всегда будет 0. Но x*(1/x) не всегда будет 1;-)
Мой ответ на главный вопрос: "Есть ли значение x с плавающей запятой, для которого xx == 0 является ложным?" это: по крайней мере, реализация с плавающей запятой на процессорах Intel не дает арифметического занижения в операциях "+" и "-", поэтому вы не сможете найти x, для которого xx == 0 равно false. То же самое верно для всех процессоров, которые поддерживают IEEE 754-2008 (см. Ссылки ниже).
Мой короткий ответ на другой ваш вопрос: если (xy == 0) точно так же безопасно, как если бы (x == y), значит assert(xx == 0) в порядке, потому что в xx или (не будет произведено арифметическое занижение) х).
Причина в следующем. Число с плавающей запятой / двойное число будет храниться в памяти в виде мантиссы и двоичного показателя. В стандартном случае мантисса нормализуется: она составляет>= 0,5 и < 1. В <float.h> Вы можете найти некоторые константы из стандарта IEEE с плавающей точкой. Интересно сейчас для нас только следующие
#define DBL_MIN 2.2250738585072014e-308 /* min positive value */
#define DBL_MIN_10_EXP (-307) /* min decimal exponent */
#define DBL_MIN_EXP (-1021) /* min binary exponent */
Но не все знают, что вы можете иметь двойные числа меньше, чем DBL_MIN. Если вы выполняете арифметические операции с числами в DBL_MIN, это число НЕ будет нормализовано, и вы будете работать с этими числами, как с целыми числами (работа только с мантиссой) без каких-либо "ошибок округления".
Замечание: я лично стараюсь не использовать слова "круглые ошибки", потому что в арифметических компьютерных операциях нет ошибок. Эти операции не совпадают с операциями +,-,* и / с теми же номерами компьютеров, что и плавающее число. Существуют детерминированные операции над подмножеством чисел с плавающей запятой, которые можно сохранить в форме (мантисса, экспонента) с четко определенным числом битов для каждого. Такое подмножество чисел с плавающей точкой мы можем назвать как число с плавающей точкой компьютера. Таким образом, результат классической операции с плавающей запятой будет спроецирован обратно на компьютер с плавающей запятой. Такая проекционная операция является детерминированной и имеет множество особенностей, например, если x1 >= x2, то x1*y >= x2*y.
Извините за длинное замечание и вернемся к нашей теме.
Чтобы точно показать, что у нас есть, если мы оперируем числами, меньшими DBL_MIN, я написал небольшую программу на C:
#include <stdio.h>
#include <float.h>
#include <math.h>
void DumpDouble(double d)
{
unsigned char *b = (unsigned char *)&d;
int i;
for (i=1; i<=sizeof(d); i++) {
printf ("%02X", b[sizeof(d)-i]);
}
printf ("\n");
}
int main()
{
double x, m, y, z;
int exp;
printf ("DBL_MAX=%.16e\n", DBL_MAX);
printf ("DBL_MAX in binary form: ");
DumpDouble(DBL_MAX);
printf ("DBL_MIN=%.16e\n", DBL_MIN);
printf ("DBL_MIN in binary form: ");
DumpDouble(DBL_MIN);
// Breaks the floating point number x into its binary significand
// (a floating point value between 0.5(included) and 1.0(excluded))
// and an integral exponent for 2
x = DBL_MIN;
m = frexp (x, &exp);
printf ("DBL_MIN has mantissa=%.16e and exponent=%d\n", m, exp);
printf ("mantissa of DBL_MIN in binary form: ");
DumpDouble(m);
// ldexp() returns the resulting floating point value from
// multiplying x (the significand) by 2
// raised to the power of exp (the exponent).
x = ldexp (0.5, DBL_MIN_EXP); // -1021
printf ("the number (x) constructed from mantissa 0.5 and exponent=DBL_MIN_EXP (%d) in binary form: ", DBL_MIN_EXP);
DumpDouble(x);
y = ldexp (0.5000000000000001, DBL_MIN_EXP);
m = frexp (y, &exp);
printf ("the number (y) constructed from mantissa 0.5000000000000001 and exponent=DBL_MIN_EXP (%d) in binary form: ", DBL_MIN_EXP);
DumpDouble(y);
printf ("mantissa of this number saved as double will be displayed by printf(%%.16e) as %.16e and exponent=%d\n", m, exp);
y = ldexp ((1 + DBL_EPSILON)/2, DBL_MIN_EXP);
m = frexp (y, &exp);
printf ("the number (y) constructed from mantissa (1+DBL_EPSILON)/2 and exponent=DBL_MIN_EXP (%d) in binary form: ", DBL_MIN_EXP);
DumpDouble(y);
printf ("mantissa of this number saved as double will be displayed by printf(%%.16e) as %.16e and exponent=%d\n", m, exp);
z = y - x;
m = frexp (z, &exp);
printf ("z=y-x in binary form: ");
DumpDouble(z);
printf ("z will be displayed by printf(%%.16e) as %.16e\n", z);
printf ("z has mantissa=%.16e and exponent=%d\n", m, exp);
if (x == y)
printf ("\"if (x == y)\" say x == y\n");
else
printf ("\"if (x == y)\" say x != y\n");
if ((x-y) == 0)
printf ("\"if ((x-y) == 0)\" say \"(x-y) == 0\"\n");
else
printf ("\"if ((x-y) == 0)\" say \"(x-y) != 0\"\n");
}
Этот код выдает следующий вывод:
DBL_MAX=1.7976931348623157e+308
DBL_MAX in binary form: 7FEFFFFFFFFFFFFF
DBL_MIN=2.2250738585072014e-308
DBL_MIN in binary form: 0010000000000000
DBL_MIN has mantissa=5.0000000000000000e-001 and exponent=-1021
mantissa of DBL_MIN in binary form: 3FE0000000000000
the number (x) constructed from mantissa 0.5 and exponent=DBL_MIN_EXP (-1021) in binary form: 0010000000000000
the number (y) constructed from mantissa 0.5000000000000001 and exponent=DBL_MIN_EXP (-1021) in binary form: 0010000000000001
mantissa of this number saved as double will be displayed by printf(%.16e) as 5.0000000000000011e-001 and exponent=-1021
the number (y) constructed from mantissa (1+DBL_EPSILON)/2 and exponent=DBL_MIN_EXP (-1021) in binary form: 0010000000000001
mantissa of this number saved as double will be displayed by printf(%.16e) as 5.0000000000000011e-001 and exponent=-1021
z=y-x in binary form: 0000000000000001
z will be displayed by printf(%.16e) as 4.9406564584124654e-324
z has mantissa=5.0000000000000000e-001 and exponent=-1073
"if (x == y)" say x != y
"if ((x-y) == 0)" say "(x-y) != 0"
Итак, мы можем видеть, что если мы будем работать с числами, меньшими DBL_MIN, они не будут нормализованы (см. 0000000000000001). Мы работаем с этими числами как с целыми числами и без каких-либо "ошибок". Таким образом, если мы назначим y=x затем if (x-y == 0) точно так же безопасно, как if (x == y), а также assert(x-x == 0) работает нормально. В этом примере z = 0,5 * 2 ^(-1073) = 1 * 2 ^(-1072). Это число действительно наименьшее число, которое мы можем сохранить в два раза. Вся арифметическая операция с числами, меньшими DBL_MIN, работает как целое число, умноженное на 2 ^ (- 1072).
Так что у меня нет проблем с потерей памяти на моем компьютере с Windows 7 с процессором Intel. Если у кого-то есть другой процессор, было бы интересно сравнить наши результаты.
У кого-нибудь есть идея, как можно получить арифметическое занижение с помощью операций - или +? Мои эксперименты выглядят так, что это невозможно.
Отредактировано: я немного изменил код для лучшей читаемости кода и сообщений.
ДОБАВЛЕННЫЕ ССЫЛКИ: Мои эксперименты показывают, что http://grouper.ieee.org/groups/754/faq.html абсолютно правильно работает на моем процессоре Intel Core 2. То, как он будет рассчитан, не приводит к потере значимости в операциях с "+" и "-". Мои результаты не зависят от строгого (/fp: строгого) или точного (/fp: точного) переключателя компилятора Microsoft Visual C (см. http://msdn.microsoft.com/en-us/library/e7s85ffb%28VS.80%29.aspx и http://msdn.microsoft.com/en-us/library/Aa289157)
Еще одна (вероятно, последняя) ссылка и мое последнее замечание: я нашел хорошую ссылку http://en.wikipedia.org/wiki/Subnormal_numbers, где описано то же самое, что я написал ранее. Включение денормальных чисел или денормализованных чисел (в настоящее время их часто называют субнормальными числами, например, в IEEE 754-2008) следует следующему утверждению:
"Денормальные числа обеспечивают гарантию того, что сложение и вычитание чисел с плавающей запятой никогда не искажается; два соседних числа с плавающей точкой всегда имеют представимую ненулевую разницу. Без постепенного понижения вычитание a-b может опуститься и привести к нулю, даже если значения не равны ".
Поэтому все мои результаты должны быть правильными на любом процессоре, который поддерживает IEEE 754-2008.
Да, сам вычитание всегда должно приводить к нулю, за исключением особых случаев.
Проблема возникает, когда вы добавляете, вычитаете, умножаете или делите перед сравнением, в котором корректируются показатель степени и мантисса. Когда показатели одинаковы, мантиссы вычитаются, и если они одинаковы, все заканчивается на нуле.
Что касается того, что говорит Марк - проверьте эту ссылку http://www.parashift.com/c++-faq-lite/newbie.html. (Не уверен, если это относится к вашей ситуации, хотя.)