Hash value of three doubles - swift

Question

Have object holds three values of doubles. Two objects are equal if all three values are equal in any possible combination. Need a function to determine number of "unique" objects in array.
I think about make Set from array and return count, but conforming to Hashable protocol requires hashValue function...
Coding on Swift but algorithm on any language (except alien) would be appreciated :)
So I need hashValue of three doubles (order of values doesn't matter) or any other solution of determining number unique objects in array
UPDATE: "Unique" means not equal. As I said above equal of two objects with double values (a, b, c for example) is equal of all three values in any possible combinations. For example:
obj1 = (a: 1, b: 2, c: 3)
obj2 = (a: 3, b: 2, c: 1)
// obj1 is equal obj2

Answer 1

Here is an example of making a class holding 3 Doubles Hashable so that you can use Set to determine how many unique ones are held in an array:
class Triple: Hashable {
var a: Double
var b: Double
var c: Double
// hashValue need only be the same for "equal" instances of the class,
// so the hashValue of the smallest property will suffice
var hashValue: Int {
return min(a, b, c).hashValue
}
init(a: Double, b: Double, c: Double) {
self.a = a
self.b = b
self.c = c
}
}
// Protocol Hashable includes Equatable, so implement == for type Triple:
// Compare sorted values to determine equality
func ==(lhs: Triple, rhs: Triple) -> Bool {
return [lhs.a, lhs.b, lhs.c].sorted() == [rhs.a, rhs.b, rhs.c].sorted()
}
let t1 = Triple(a: 3, b: 2, c: 1)
let t2 = Triple(a: 1, b: 2, c: 3)
let t3 = Triple(a: 1, b: 3, c: 2)
let t4 = Triple(a: 3, b: 3, c: 2)
let arr = [t1, t2, t3, t4]
// Find out how many unique Triples are in the array:
let set = Set(arr)
print(set.count) // 2
Discussion: A better hashing function
As #PatriciaShanahan noted in the comments, using min in the computation of hashValue has a couple of drawbacks:
min can be expensive since it involves comparisons.
Only considering the smallest item when computing the hashValue for Triple will result in many "common" Triples with the same hashValue. For instance, any Triple with a value of 0 and two positive values would have the same hashValue.
I chose min because I felt it was easy to understand that the min(a, b, c) would result in the same value for all orderings of a, b, and c which means we'd get the same hashValue for all orderings. That is important because since we are considering Triples to be equal independent of the orderings of the 3 values, the hashValue must be the same for any ordering of the values since a == b implies a.hashValue == b.hashValue.
I had considered other hashing functions such as:
(a + b + c).hashValue
(a * b * c).hashValue
but these are flawed. Mathematically speaking, addition and multiplication are commutative, so theoretically these would result in the same hashValue no matter the order of a, b, and c. But, in practice, changing the order of operations could result in an overflow or underflow.
Consider the following example:
let a = Int.max
let b = Int.min
let c = 5
let t1 = (a + b) + c // 4
let t2 = (a + c) + b // Overflow!
An ideal hashing function for class Triplewould:
Guarantee the same hashValue for all orderings of a, b, and c.
Be fast to compute.
Would change the result if any of a, b, or c change.
Could not overflow or underflow.
One good mathematical operation for combining numbers is the bitwise OR function ^. It combines two values by comparing them bitwise and setting the resulting bit to 0 if both bits are the same and to 1 if the bits are different.
a b result
--- --- ------
0 0 0
0 1 1
1 0 1
1 1 0
Extending this to 3 values:
a b c result
--- --- --- ------
0 0 0 0
0 0 1 1
0 1 0 1
0 1 1 0
1 0 0 1
1 0 1 0
1 1 0 0
1 1 1 1
As shown in the table above, XOR(0, 0, 0) = 0 for all orderings, XOR(1, 0, 0) = 1 for all orderings, XOR(1, 1, 0) = 0 for all orderings, and XOR(1, 1, 1) = 1 for all orderings. So using exclusive OR to combine the values meets the first criterium of providing the same result for all orderings.
Exclusive OR is a fast operation. It is implemented by a single assembly instruction. So it meets the second criterium of a good hashing function.
If any of a, b, or c changes, then the result of a ^ b ^ c would change. So exclusive OR meets the third criterium of a good hashing function.
Exclusive OR cannot overflow or underflow because it simply sets the bits. So it meets the fourth criterium of a good hashing function.
Thus, a better hashing function would be:
var hashValue: Int {
return a.hashValue ^ b.hashValue ^ c.hashValue
}