Привет, All =)

в общем вот есть код с комментариями:


Кто что об этом думает?   

Интерестный вопрос. Вот код класса ValueType (род. класс структуры):


Прошелся дебаггером - фолс возвращает в месте где вызываеться CanCompareBits а затем FastEqualsCheck. К несчастью оба метода имеют анменейдж реализацию, и я неуверен что они делают - мое предположоние, судя по названию, просто сравнивают биты структур в памяти.

Если руководиться этим выходит что при double a = 0.0; и double b = -0.0; а и b имеют одинаковое значение, но не одинаковые внутренние поля (например, кажись там есть поле _isNegative или что-то подобное) - а поэтому сравнивание происходит не так как бы хотелось.

Надеюсь что прав. Если есть мастера у которых другой ответ - образумьте   

на самом деле хуже то что true выдается...
вообще он и не должен как раз появляться, числа 0.0 и -0.0 это разные числа... подробне можно найти в IEEE чета там, про машинное представление числа в общем....

Точно. Как-то в эту сторону не подумал 
Спецификация double (IEEE 754)
Только видать .нет при обработке Equals игнорирует разницу, ибо:

Выдаст true ;)
Что в общем правильно. Только в памяти то они разные.
-0 = 1 11111111 00000000000000000000000
0 = 0 11111111 00000000000000000000000

Поэтому во-втором случае еквалс таких структур возвращает false.
В первом случае, оно почему-то решает что существуют ссылки из GC в структуре и поэтому отказываеться от сравнения по битам, а сравнивает по полям - что призводит к ответу в true

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

Тоже так думал, но в реализации double такого нет. Разве что есть ведущий флаг отвечающий за отрицательность числа - но он есть и у int.

Итак, есть люди, которые могут до конца прояснить логику такого неоднозначного поведения?   

Есть они работают в MS 

Вот - нашел - всетаки в стандарте это есть:

C# supports two floating-point types: float and double. The float and double types are represented
using the 32-bit single-precision and 64-bit double-precision IEC 60559 formats, which provide the
following sets of values:
• Positive zero and negative zero. In most situations, positive zero and negative zero behave identically as
the simple value zero, but certain operations distinguish between the two (§14.7.2).
• Positive infinity and negative infinity. Infinities are produced by such operations as dividing a non-zero
number by zero. [Example: 1.0 / 0.0 yields positive infinity, and –1.0 / 0.0 yields negative infinity.
end example]
• The Not-a-Number value, often abbreviated NaN. NaNs are produced by invalid floating-point
operations, such as dividing zero by zero.
• The finite set of non-zero values of the form s × m × 2e, where s is 1 or −1, and m and e are determined
by the particular floating-point type: For float, 0 < m < 224 and −149 ≤ e ≤ 104, and for double,
0 < m < 253 and −1075 ≤ e ≤ 970. Denormalized floating-point numbers are considered valid non-zero
values. C# neither requires nor forbids that a conforming implementation support denormalized floatingpoint
numbers.


Т.е. для float и для double есть константные значение +0 и -0.

Добавлено через 2 минуты и 35 секунд
Стандарт всетаки великая вещь, я вчера пытался в нем выискать особенности работы Equals для double - ничего не нашел, подумал что это какая-то недокументированная особенность. А сегодня посмотрел описалово double - в первой же строке объяснение 

HalkaR, ненененене )
мне не понятна другая вещь)

почему в первом случае 0.0 и -0.0 при сравнении структур воспринимаются как равные,
а во втором - как отличные друг от друга?

ведь по сути операция - одна и та же... вызывается Equals для ValueType...

ОК. Где бы взять код анменейдж методов CanCompareBits и FastEqualsCheck ? 
Проблема именно в них. Все другое работает правильно

Инт не отличает -0 от 0. В памяти и то и то выглядит как 000000....
Походу -0 и 0 есть только в double и float

Это сообщение отредактировал(а) archeg - 7.10.2008, 11:56

Потому что double хранится в памяти совершенно извратно и для -0 у него есть специальная константа далеко не равная 0. Если интересно - она равна - BitConverter.Int64BitsToDouble(-9223372036854775808L); У int все проще - у него нет таких констант.

Если бы все было так просто, тогда почему же в 1-м случае результат true? В первом те же даблы с +0 и -0

HalkaR, а какая разница? переменные, хранящие 0.0 и -0.0 в обоих структурах (и D1, и D2) имеют тип double   

Partizan, еще раз повторяю - это для тебя -0 и +0 это одно и тоже. Для типа double в C# -0 - это специальная константа, которая хранится в памяти не как 0.

Добавлено через 42 секунды
То, что при отладке студия показывает значение это константы как 0 - ничего не значит - во внутреннем представлении double  - это не тоже самое что 0.

Добавлено через 1 минуту и 47 секунд

Мда.. тут пока загадка.

Добавлено через 2 минуты и 5 секунд

Хм, еще непонятно.

HalkaR, да для меня +0.0 и -0.0 - это тоже разные вещи....я просто не понимаю, почему в одном случае Equals их воспринимает как одинаковые, а в другом - нет...

Добавлено через 1 минуту и 20 секунд
кстати разведка доложила, что жаба в обоих случаях возвращает false.