On 12/09/2016 09:45 AM, Ben Coman wrote:
The suggested fix depended on being willing to let go of byte ordering
(which we might not want different results on different platforms)
Float>>hash
^ByteArray
hashBytes: self
startingWith: self species hash
This fix contains a good idea, but has at least two problems:
1) The check for integers is important, that's what makes sure that 1.0
has the same hash as 1. Which it must, since they compare equal.
2) #hashBytes:startingWith: is designed to hash *bytes*. A BoxedFloat64
is two *words*, which ensures that when you hashMultiply the high-order
bits of each word get discarded.
I tried implementing a hash that actually uses the bytes of the float
(code at bottom of this message). I didn't do any real analysis of it,
but at least it gives different answers for 0.5 and -0.5. I think it
matches the *intent* of the code above (though would still need the
integer check, which I didn't bother with).
but anyway that doesn't actually help this case...
-0.5 hash "==>120484352"
0.5 hash "==>120484352"
I see Squeak5's float hash has changed...
Float>>hash "Squeak5"
(self isFinite and: [self fractionPart = 0.0]) ifTrue: [^self
truncated hash].
^ ((self basicAt: 1) bitShift: -4) +
((self basicAt: 2) bitShift: -4)
This is slightly better. It's only discarding eight bits out of 64,
instead of discarding 32. But it would be better to mix all the bits
into the hash.
Note that all of these hash implementations end up manipulating at least
one large integer most of the time, since each word can be a large
integer. It's possible that a primitive to copy a word object into the
equivalent bytes might speed things up somewhat.
Regards,
-Martin
"Strictly experimental method on BoxedFloat64, could probably be made
faster even without a primitive."
bytesHash
| bytes word1 word2 |
bytes := ByteArray new: 8.
word1 := self basicAt: 1.
word2 := self basicAt: 2.
bytes at: 1 put: (word1 bitShift: -24).
bytes at: 2 put: ((word1 bitShift: -16) bitAnd: 16rFF).
bytes at: 3 put: ((word1 bitShift: -8) bitAnd: 16rFF).
bytes at: 4 put: (word1 bitAnd: 16rFF).
bytes at: 5 put: (word2 bitShift: -24).
bytes at: 6 put: ((word2 bitShift: -16) bitAnd: 16rFF).
bytes at: 7 put: ((word2 bitShift: -8) bitAnd: 16rFF).
bytes at: 8 put: (word2 bitAnd: 16rFF).
^ ByteArray hashBytes: bytes startingWith: self class hash
