Overriding Equals and GetHashcode and double comparison - c#-4.0

Question

I have a problem with equality and adding objects to dictionary
class DoublePoint
{
public double X;
public double Y;
public double Z;
public DoublePoint(double x, double y, double z)
{
this.X = x; this.Y = y; this.Z = z;
}
public override bool Equals(object obj)
{
try
{
DoublePoint dPoint = obj as DoublePoint;
return this.X.IsEqualTo(dPoint.X) && this.Y.IsEqualTo(dPoint.Y) && this.Z.IsEqualTo(dPoint.Z);
}
catch
{
throw;
}
}
public override int GetHashCode()
{
return this.X.GetCode() ^ this.Y.GetCode() ^ this.Z.GetCode();
}
}
static class extensions
{
static double Tolerance = 0.001;
public static bool IsEqualTo(this double d1, double d2)
{
return (d1 - d2) <= Tolerance;
}
public static int GetCode(this double d1)
{
byte[] data = BitConverter.GetBytes(d1);
int x = BitConverter.ToInt32(data, 0);
int y = BitConverter.ToInt32(data, 4);
return x ^ y;
}
}
and here is my test:
DoublePoint d1 = new DoublePoint(1.200, 2.3, 3.4);
DoublePoint d2 = new DoublePoint(1.2001, 2.3, 3.4);
DoublePoint d3 = new DoublePoint(1.200, 2.3, 3.4);
bool isEqual = d1.Equals(d2); // true here
Dictionary<DoublePoint, int> dict = new Dictionary<DoublePoint, int>();
dict.Add(d1, 1);
dict.Add(d2, 2); // successful, d2 is also added but d2 is equal to d1
dict.Add(d3, 3); // Error! since we have d1 already in dictionary
With this,
when I add doublpoint objects which are same(with some tolerance), I am able to add them in dictionary. How to restrict such objects.
Is the right way to compare double data types with some tolerance.
Please advice.
Thank you

Answer 1

There is a problem with defining "equal" as "close enough". It is no doubt useful for computations, but such "equal" violates the transitivity rule: for Equals if a.Equals(b) && b.Equals(c), then a.Equals(c) must hold true (which is obviously not the property of your code).
So, IsEqualTo is unfortunately not suitable for redefining Equals.
What are the possible ways to solve the problem? Equals has to split into the disjoint groups of "equivalent" values. I usually do the following: define a rule to get the "canonical" value from a group, so two values are "equal" iff their canonical group representatives are equal.
Simple example: for just a double value d let's define the canonical value to be Math.Floor(d). So this way you have 1.0 equals 1.1, 0.9 equals to 0.0 but doesn't equal to 1.0. This way is not the ideal one (after all, 0.9 being not equal to 1.0 but equal to 0.0 seems to be wrong), but at least the transitivity rule is held.
Specifically for your case it could be this way:
class DoublePoint
{
public double X;
public double Y;
public double Z;
const double epsilon;
void GetCanonicalValues(out double x, out double y, out double z)
{
x = Math.Floor(X / epsilon) * epsilon;
y = Math.Floor(Y / epsilon) * epsilon;
z = Math.Floor(Z / epsilon) * epsilon;
}
public override bool Equals(object obj)
{
DoublePoint that = obj as DoublePoint;
if (that == null)
return false;
double x1, y1, z1, x2, y2, z2;
this.GetCanonicalValues(out x1, out x2, out z2);
that.GetCanonicalValues(out x1, out x2, out z2);
return (x1 == x2) && (y1 == y2) && (z1 == z2); // here we can compare
}
...
Another problem with your code is that your GetHashCode is not aligned with Equals: if a.Equals(b) then a.GetHashCode() must equal b.GetHashCode().
You can solve this as well by using the canonical values:
public override int GetHashCode()
{
double x, y, z;
GetCanonicalValues(out x, out y, out z);
return x.GetHashCode() ^ y.GetHashCode() ^ z.GetCode();
}
}
Beware that the behaviour of Equals may be unacceptable for your needs -- then you'll need to ensure the transitivity some other way.