Fixed class diagram & small changes

stefan-baumann · stefan-baumann · commit ac3c27c55439 · 2016-03-26T20:57:22.000+01:00
diff --git a/SharpMath.Tests/PolygonTest.cs b/SharpMath.Tests/PolygonTest.cs
@@ -33,7 +33,7 @@ public void CanCalculateArea()
         {
             var square =
                 new Polygon(new Point2D(0, 0), new Point2D(2, 0), new Point2D(2, 2), new Point2D(0, 2));
-            Assert.IsTrue(FloatingNumber.CheckApproximatelyEqual(4, square.Area));
+            Assert.IsTrue(FloatingNumber.AreApproximatelyEqual(4, square.Area));
 
             var triangle =
                 new Polygon(new Point2D(0, 0), new Point2D(2, 0), new Point2D(1, 2));
diff --git a/SharpMath.Tests/VectorTest.cs b/SharpMath.Tests/VectorTest.cs
@@ -112,7 +112,7 @@ public void CanRotateTwoDimensionalVector()
         {
             var firstVector = new Vector2(0, 1);
             var rotatedVector = Matrix3x3.Rotation(MathHelper.DegreesToRadians(180))*firstVector;
-            Assert.IsTrue(FloatingNumber.CheckApproximatelyEqual(firstVector.X, 0));
+            Assert.IsTrue(FloatingNumber.AreApproximatelyEqual(firstVector.X, 0));
             Assert.AreEqual(-1, rotatedVector.Y);
         }
 
@@ -156,7 +156,7 @@ public void CanCalculateArea()
             var thirdVector = new Vector2(2, 4);
             var fourthVector = new Vector2(3, 1);
             double secondArea = Vector2.Area(thirdVector, fourthVector);
-            Assert.IsTrue(FloatingNumber.CheckApproximatelyEqual(10, secondArea));
+            Assert.IsTrue(FloatingNumber.AreApproximatelyEqual(10, secondArea));
         }
 
         [TestMethod]
diff --git a/SharpMath/FloatingNumber.cs b/SharpMath/FloatingNumber.cs
@@ -22,8 +22,8 @@ public static class FloatingNumber
         /// <param name="firstNumber">The first <see cref="float" />.</param>
         /// <param name="secondNumber">The second <see cref="float" />.</param>
         /// <returns>Returns <c>true</c>, if they are approximately equal, otherwise <c>false</c>.</returns>
-        public static bool CheckApproximatelyEqual(float firstNumber, float secondNumber)
-            => CheckApproximatelyEqual(firstNumber, secondNumber, Epsilon);
+        public static bool AreApproximatelyEqual(float firstNumber, float secondNumber)
+            => AreApproximatelyEqual(firstNumber, secondNumber, Epsilon);
 
         /// <summary>
         ///     Determines whether two floating numbers are approximately equal to each other using the specified epsilon value.
@@ -32,8 +32,8 @@ public static bool CheckApproximatelyEqual(float firstNumber, float secondNumber
         /// <param name="secondNumber">The second <see cref="float" />.</param>
         /// <param name="epsilon">The epsilon value that represents the tolerance.</param>
         /// <returns>Returns <c>true</c>, if they are approximately equal, otherwise <c>false</c>.</returns>
-        public static bool CheckApproximatelyEqual(float firstNumber, float secondNumber, double epsilon)
-            => Math.Abs(firstNumber - secondNumber) <= Epsilon;
+        public static bool AreApproximatelyEqual(float firstNumber, float secondNumber, double epsilon)
+            => Math.Abs(firstNumber - secondNumber) <= epsilon;
         
         /// <summary>
         ///     Determines whether two floating numbers are approximately equal to each other using the <see cref="Epsilon" />
@@ -42,8 +42,8 @@ public static bool CheckApproximatelyEqual(float firstNumber, float secondNumber
         /// <param name="firstNumber">The first <see cref="float" />.</param>
         /// <param name="secondNumber">The second <see cref="float" />.</param>
         /// <returns>Returns <c>true</c>, if they are approximately equal, otherwise <c>false</c>.</returns>
-        public static bool CheckApproximatelyEqual(double firstNumber, double secondNumber)
-            => CheckApproximatelyEqual(firstNumber, secondNumber, Epsilon);
+        public static bool AreApproximatelyEqual(double firstNumber, double secondNumber)
+            => AreApproximatelyEqual(firstNumber, secondNumber, Epsilon);
 
         /// <summary>
         ///     Determines whether two floating numbers are approximately equal to each other using the specified epsilon value.
@@ -52,7 +52,7 @@ public static bool CheckApproximatelyEqual(double firstNumber, double secondNumb
         /// <param name="secondNumber">The second <see cref="float" />.</param>
         /// <param name="epsilon">The epsilon value that represents the tolerance.</param>
         /// <returns>Returns <c>true</c>, if they are approximately equal, otherwise <c>false</c>.</returns>
-        public static bool CheckApproximatelyEqual(double firstNumber, double secondNumber, double epsilon)
-            => Math.Abs(firstNumber - secondNumber) <= Epsilon;
+        public static bool AreApproximatelyEqual(double firstNumber, double secondNumber, double epsilon)
+            => Math.Abs(firstNumber - secondNumber) <= epsilon;
     }
 }
diff --git a/SharpMath/FloatingNumberExtensions.cs b/SharpMath/FloatingNumberExtensions.cs
@@ -16,7 +16,7 @@ public static class FloatingNumberExtensions
         /// <param name="other">The other <see cref="float" />.</param>
         /// <returns>Returns <c>true</c>, if they are approximately equal, otherwise <c>false</c>.</returns>
         public static bool IsApproximatelyEqualTo(this float number, float other)
-            => FloatingNumber.CheckApproximatelyEqual(number, other);
+            => FloatingNumber.AreApproximatelyEqual(number, other);
 
         /// <summary>
         ///     Determines whether two floating numbers are approximately equal to each other using the specified epsilon value.
@@ -26,7 +26,7 @@ public static bool IsApproximatelyEqualTo(this float number, float other)
         /// <param name="epsilon">The epsilon value that represents the tolerance.</param>
         /// <returns>Returns <c>true</c>, if they are approximately equal, otherwise <c>false</c>.</returns>
         public static bool IsApproximatelyEqualTo(this float number, float other, double epsilon)
-            => FloatingNumber.CheckApproximatelyEqual(number, other, epsilon);
+            => FloatingNumber.AreApproximatelyEqual(number, other, epsilon);
 
         /// <summary>
         ///     Determines whether two floating numbers are approximately equal to each other using the <see cref="Epsilon" />
@@ -36,7 +36,7 @@ public static bool IsApproximatelyEqualTo(this float number, float other, double
         /// <param name="other">The other <see cref="float" />.</param>
         /// <returns>Returns <c>true</c>, if they are approximately equal, otherwise <c>false</c>.</returns>
         public static bool IsApproximatelyEqualTo(this double number, double other)
-            => FloatingNumber.CheckApproximatelyEqual(number, other);
+            => FloatingNumber.AreApproximatelyEqual(number, other);
 
         /// <summary>
         ///     Determines whether two floating numbers are approximately equal to each other using the specified epsilon value.
@@ -46,6 +46,6 @@ public static bool IsApproximatelyEqualTo(this double number, double other)
         /// <param name="epsilon">The epsilon value that represents the tolerance.</param>
         /// <returns>Returns <c>true</c>, if they are approximately equal, otherwise <c>false</c>.</returns>
         public static bool IsApproximatelyEqualTo(this double number, double other, double epsilon)
-            => FloatingNumber.CheckApproximatelyEqual(number, other, epsilon);
+            => FloatingNumber.AreApproximatelyEqual(number, other, epsilon);
     }
 }
diff --git a/SharpMath/Geometry/Line2D.cs b/SharpMath/Geometry/Line2D.cs
@@ -87,7 +87,7 @@ public bool IsPointOnLine(Point2D point)
         /// </returns>
         public bool IsParallelTo(Line2D line)
         {
-            return FloatingNumber.CheckApproximatelyEqual(Slope, line.Slope);
+            return FloatingNumber.AreApproximatelyEqual(Slope, line.Slope);
         }
 
         /// <summary>
diff --git a/SharpMath/Geometry/Line3D.cs b/SharpMath/Geometry/Line3D.cs
@@ -75,7 +75,7 @@ public bool IsPointOnLine(Point3D point)
             for (uint i = 0; i < 3; ++i)
             {
                 double value = (point[i] - Point[i])/Direction[i];
-                if (i != 0 && !FloatingNumber.CheckApproximatelyEqual(value, lambda))
+                if (i != 0 && !FloatingNumber.AreApproximatelyEqual(value, lambda))
                     return false;
                 lambda = value;
             }
diff --git a/SharpMath/Geometry/Matrix.cs b/SharpMath/Geometry/Matrix.cs
@@ -77,8 +77,8 @@ public bool IsDiagonal
                 for (uint y = 0; y < RowCount; ++y)
                     for (uint x = 0; x < ColumnCount; ++x)
                     {
-                        if ((y == x && FloatingNumber.CheckApproximatelyEqual(this[y, x], 0)) ||
-                            (y != x && !FloatingNumber.CheckApproximatelyEqual(this[y, x], 0)))
+                        if ((y == x && FloatingNumber.AreApproximatelyEqual(this[y, x], 0)) ||
+                            (y != x && !FloatingNumber.AreApproximatelyEqual(this[y, x], 0)))
                             return false;
                     }
                 return true;
@@ -95,8 +95,8 @@ public bool IsTriangle
                 for (uint y = 0; y < RowCount; ++y)
                     for (uint x = 0; x < ColumnCount; ++x)
                     {
-                        if ((y == x && FloatingNumber.CheckApproximatelyEqual(this[y, x], 0)) ||
-                            (y != x && !FloatingNumber.CheckApproximatelyEqual(this[y, x], 0)))
+                        if ((y == x && FloatingNumber.AreApproximatelyEqual(this[y, x], 0)) ||
+                            (y != x && !FloatingNumber.AreApproximatelyEqual(this[y, x], 0)))
                             return false;
                     }
                 return true;
@@ -328,7 +328,7 @@ public static bool AreEqual(Matrix firstMatrix, Matrix secondMatrix)
             {
                 for (uint x = 0; x < firstMatrix.ColumnCount; ++x)
                 {
-                    if (!FloatingNumber.CheckApproximatelyEqual(firstMatrix[y, x], secondMatrix[y, x]))
+                    if (!FloatingNumber.AreApproximatelyEqual(firstMatrix[y, x], secondMatrix[y, x]))
                         return false;
                 }
             }
@@ -589,7 +589,7 @@ public override int GetHashCode()
             {
                 for (uint x = 0; x < left.ColumnCount; ++x)
                 {
-                    if (!FloatingNumber.CheckApproximatelyEqual(left[y, x], right[y, x]))
+                    if (!FloatingNumber.AreApproximatelyEqual(left[y, x], right[y, x]))
                         return false;
                 }
             }
@@ -617,7 +617,7 @@ public override int GetHashCode()
             {
                 for (uint x = 0; x < left.ColumnCount; ++x)
                 {
-                    if (!FloatingNumber.CheckApproximatelyEqual(left[y, x], right[y, x]))
+                    if (!FloatingNumber.AreApproximatelyEqual(left[y, x], right[y, x]))
                         return true;
                 }
             }
diff --git a/SharpMath/Geometry/Point.cs b/SharpMath/Geometry/Point.cs
@@ -286,7 +286,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < left.Dimension; ++i)
             {
-                if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
@@ -311,7 +311,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < left.Dimension; ++i)
             {
-                if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return true;
             }
 
diff --git a/SharpMath/Geometry/Point2D.cs b/SharpMath/Geometry/Point2D.cs
@@ -169,7 +169,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < 2; ++i)
             {
-                if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
@@ -191,7 +191,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < 2; ++i)
             {
-                if (FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
diff --git a/SharpMath/Geometry/Point3D.cs b/SharpMath/Geometry/Point3D.cs
@@ -177,7 +177,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < 3; ++i)
             {
-                if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
@@ -199,7 +199,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < 3; ++i)
             {
-                if (FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
diff --git a/SharpMath/Geometry/Polygon.cs b/SharpMath/Geometry/Polygon.cs
@@ -175,7 +175,7 @@ private int ContainsPointInternal(Point2D q, Point2D p1, Point2D p2)
                 p1 = p2;
                 p2 = currentP1;
             }
-            else if (FloatingNumber.CheckApproximatelyEqual(q.Y, p1.Y) && FloatingNumber.CheckApproximatelyEqual(q.X, p1.X))
+            else if (FloatingNumber.AreApproximatelyEqual(q.Y, p1.Y) && FloatingNumber.AreApproximatelyEqual(q.X, p1.X))
                 return 0;
             else if (q.Y <= p1.Y || q.Y > p2.Y)
                 return 1;
diff --git a/SharpMath/Geometry/Vector.cs b/SharpMath/Geometry/Vector.cs
@@ -99,11 +99,11 @@ public double SquareMagnitude
         /// <summary>
         ///     Gets a value indicating whether this <see cref="Vector" /> is normalized, or not.
         /// </summary>
-        public bool IsNormalized => FloatingNumber.CheckApproximatelyEqual(Magnitude, 1);
+        public bool IsNormalized => FloatingNumber.AreApproximatelyEqual(Magnitude, 1);
 
         private bool IsZeroVector
         {
-            get { return this.All(c => FloatingNumber.CheckApproximatelyEqual(c, 0)); }
+            get { return this.All(c => FloatingNumber.AreApproximatelyEqual(c, 0)); }
         }
 
         /// <summary>
@@ -347,7 +347,7 @@ public bool IsOrthogonalTo(Vector other)
             if (Dimension != other.Dimension)
                 throw new DimensionException("The dimensions of the vectors do not equal each other.");
 
-            return !IsZeroVector && !other.IsZeroVector && FloatingNumber.CheckApproximatelyEqual(ScalarProduct(other), 0);
+            return !IsZeroVector && !other.IsZeroVector && FloatingNumber.AreApproximatelyEqual(ScalarProduct(other), 0);
         }
 
         /// <summary>
@@ -405,7 +405,7 @@ public bool IsParallelTo(Vector other)
                     firstResult = other[i]/this[i];
                 else
                 {
-                    if (!FloatingNumber.CheckApproximatelyEqual(other[i]/this[i], firstResult))
+                    if (!FloatingNumber.AreApproximatelyEqual(other[i]/this[i], firstResult))
                         return false;
                 }
             }
@@ -661,7 +661,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < left.Dimension; ++i)
             {
-                if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
@@ -686,7 +686,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < left.Dimension; ++i)
             {
-                if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return true;
             }
 
diff --git a/SharpMath/Geometry/Vector2.cs b/SharpMath/Geometry/Vector2.cs
@@ -363,7 +363,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < 2; ++i)
             {
-                if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
@@ -385,7 +385,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < 2; ++i)
             {
-                if (FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
diff --git a/SharpMath/Geometry/Vector3.cs b/SharpMath/Geometry/Vector3.cs
@@ -403,7 +403,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < 3; ++i)
             {
-                if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
@@ -425,7 +425,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < 3; ++i)
             {
-                if (FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
diff --git a/SharpMath/Geometry/Vector4.cs b/SharpMath/Geometry/Vector4.cs
@@ -197,7 +197,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < 4; ++i)
             {
-                if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
@@ -219,7 +219,7 @@ public override int GetHashCode()
 
             for (uint i = 0; i < 4; ++i)
             {
-                if (FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))
+                if (FloatingNumber.AreApproximatelyEqual(left[i], right[i]))
                     return false;
             }
 
diff --git a/SharpMath/SharpMath.cd b/SharpMath/SharpMath.cd

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public void CanCalculateArea()`
`33`	`33`	`{`
`34`	`34`	`var square =`
`35`	`35`	`new Polygon(new Point2D(0, 0), new Point2D(2, 0), new Point2D(2, 2), new Point2D(0, 2));`
`36`		`- Assert.IsTrue(FloatingNumber.CheckApproximatelyEqual(4, square.Area));`
	`36`	`+ Assert.IsTrue(FloatingNumber.AreApproximatelyEqual(4, square.Area));`
`37`	`37`
`38`	`38`	`var triangle =`
`39`	`39`	`new Polygon(new Point2D(0, 0), new Point2D(2, 0), new Point2D(1, 2));`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ public void CanRotateTwoDimensionalVector()`
`112`	`112`	`{`
`113`	`113`	`var firstVector = new Vector2(0, 1);`
`114`	`114`	`var rotatedVector = Matrix3x3.Rotation(MathHelper.DegreesToRadians(180))*firstVector;`
`115`		`- Assert.IsTrue(FloatingNumber.CheckApproximatelyEqual(firstVector.X, 0));`
	`115`	`+ Assert.IsTrue(FloatingNumber.AreApproximatelyEqual(firstVector.X, 0));`
`116`	`116`	`Assert.AreEqual(-1, rotatedVector.Y);`
`117`	`117`	`}`
`118`	`118`
`@@ -156,7 +156,7 @@ public void CanCalculateArea()`
`156`	`156`	`var thirdVector = new Vector2(2, 4);`
`157`	`157`	`var fourthVector = new Vector2(3, 1);`
`158`	`158`	`double secondArea = Vector2.Area(thirdVector, fourthVector);`
`159`		`- Assert.IsTrue(FloatingNumber.CheckApproximatelyEqual(10, secondArea));`
	`159`	`+ Assert.IsTrue(FloatingNumber.AreApproximatelyEqual(10, secondArea));`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`[TestMethod]`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ public bool IsPointOnLine(Point2D point)`
`87`	`87`	`/// </returns>`
`88`	`88`	`public bool IsParallelTo(Line2D line)`
`89`	`89`	`{`
`90`		`- return FloatingNumber.CheckApproximatelyEqual(Slope, line.Slope);`
	`90`	`+ return FloatingNumber.AreApproximatelyEqual(Slope, line.Slope);`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public bool IsPointOnLine(Point3D point)`
`75`	`75`	`for (uint i = 0; i < 3; ++i)`
`76`	`76`	`{`
`77`	`77`	`double value = (point[i] - Point[i])/Direction[i];`
`78`		`- if (i != 0 && !FloatingNumber.CheckApproximatelyEqual(value, lambda))`
	`78`	`+ if (i != 0 && !FloatingNumber.AreApproximatelyEqual(value, lambda))`
`79`	`79`	`return false;`
`80`	`80`	`lambda = value;`
`81`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,8 +77,8 @@ public bool IsDiagonal`
`77`	`77`	`for (uint y = 0; y < RowCount; ++y)`
`78`	`78`	`for (uint x = 0; x < ColumnCount; ++x)`
`79`	`79`	`{`
`80`		`- if ((y == x && FloatingNumber.CheckApproximatelyEqual(this[y, x], 0)) \|\|`
`81`		`- (y != x && !FloatingNumber.CheckApproximatelyEqual(this[y, x], 0)))`
	`80`	`+ if ((y == x && FloatingNumber.AreApproximatelyEqual(this[y, x], 0)) \|\|`
	`81`	`+ (y != x && !FloatingNumber.AreApproximatelyEqual(this[y, x], 0)))`
`82`	`82`	`return false;`
`83`	`83`	`}`
`84`	`84`	`return true;`
`@@ -95,8 +95,8 @@ public bool IsTriangle`
`95`	`95`	`for (uint y = 0; y < RowCount; ++y)`
`96`	`96`	`for (uint x = 0; x < ColumnCount; ++x)`
`97`	`97`	`{`
`98`		`- if ((y == x && FloatingNumber.CheckApproximatelyEqual(this[y, x], 0)) \|\|`
`99`		`- (y != x && !FloatingNumber.CheckApproximatelyEqual(this[y, x], 0)))`
	`98`	`+ if ((y == x && FloatingNumber.AreApproximatelyEqual(this[y, x], 0)) \|\|`
	`99`	`+ (y != x && !FloatingNumber.AreApproximatelyEqual(this[y, x], 0)))`
`100`	`100`	`return false;`
`101`	`101`	`}`
`102`	`102`	`return true;`
`@@ -328,7 +328,7 @@ public static bool AreEqual(Matrix firstMatrix, Matrix secondMatrix)`
`328`	`328`	`{`
`329`	`329`	`for (uint x = 0; x < firstMatrix.ColumnCount; ++x)`
`330`	`330`	`{`
`331`		`- if (!FloatingNumber.CheckApproximatelyEqual(firstMatrix[y, x], secondMatrix[y, x]))`
	`331`	`+ if (!FloatingNumber.AreApproximatelyEqual(firstMatrix[y, x], secondMatrix[y, x]))`
`332`	`332`	`return false;`
`333`	`333`	`}`
`334`	`334`	`}`
`@@ -589,7 +589,7 @@ public override int GetHashCode()`
`589`	`589`	`{`
`590`	`590`	`for (uint x = 0; x < left.ColumnCount; ++x)`
`591`	`591`	`{`
`592`		`- if (!FloatingNumber.CheckApproximatelyEqual(left[y, x], right[y, x]))`
	`592`	`+ if (!FloatingNumber.AreApproximatelyEqual(left[y, x], right[y, x]))`
`593`	`593`	`return false;`
`594`	`594`	`}`
`595`	`595`	`}`
`@@ -617,7 +617,7 @@ public override int GetHashCode()`
`617`	`617`	`{`
`618`	`618`	`for (uint x = 0; x < left.ColumnCount; ++x)`
`619`	`619`	`{`
`620`		`- if (!FloatingNumber.CheckApproximatelyEqual(left[y, x], right[y, x]))`
	`620`	`+ if (!FloatingNumber.AreApproximatelyEqual(left[y, x], right[y, x]))`
`621`	`621`	`return true;`
`622`	`622`	`}`
`623`	`623`	`}`
Original file line number	Diff line number	Diff line change
`@@ -286,7 +286,7 @@ public override int GetHashCode()`
`286`	`286`
`287`	`287`	`for (uint i = 0; i < left.Dimension; ++i)`
`288`	`288`	`{`
`289`		`- if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))`
	`289`	`+ if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))`
`290`	`290`	`return false;`
`291`	`291`	`}`
`292`	`292`
`@@ -311,7 +311,7 @@ public override int GetHashCode()`
`311`	`311`
`312`	`312`	`for (uint i = 0; i < left.Dimension; ++i)`
`313`	`313`	`{`
`314`		`- if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))`
	`314`	`+ if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))`
`315`	`315`	`return true;`
`316`	`316`	`}`
`317`	`317`
Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,7 @@ public override int GetHashCode()`
`169`	`169`
`170`	`170`	`for (uint i = 0; i < 2; ++i)`
`171`	`171`	`{`
`172`		`- if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))`
	`172`	`+ if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))`
`173`	`173`	`return false;`
`174`	`174`	`}`
`175`	`175`
`@@ -191,7 +191,7 @@ public override int GetHashCode()`
`191`	`191`
`192`	`192`	`for (uint i = 0; i < 2; ++i)`
`193`	`193`	`{`
`194`		`- if (FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))`
	`194`	`+ if (FloatingNumber.AreApproximatelyEqual(left[i], right[i]))`
`195`	`195`	`return false;`
`196`	`196`	`}`
`197`	`197`
Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,7 @@ public override int GetHashCode()`
`177`	`177`
`178`	`178`	`for (uint i = 0; i < 3; ++i)`
`179`	`179`	`{`
`180`		`- if (!FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))`
	`180`	`+ if (!FloatingNumber.AreApproximatelyEqual(left[i], right[i]))`
`181`	`181`	`return false;`
`182`	`182`	`}`
`183`	`183`
`@@ -199,7 +199,7 @@ public override int GetHashCode()`
`199`	`199`
`200`	`200`	`for (uint i = 0; i < 3; ++i)`
`201`	`201`	`{`
`202`		`- if (FloatingNumber.CheckApproximatelyEqual(left[i], right[i]))`
	`202`	`+ if (FloatingNumber.AreApproximatelyEqual(left[i], right[i]))`
`203`	`203`	`return false;`
`204`	`204`	`}`
`205`	`205`