diff --git a/ANX.Framework.TestCenter/AssertHelper.cs b/ANX.Framework.TestCenter/AssertHelper.cs
index 5151128d..9c7a8bc5 100644
--- a/ANX.Framework.TestCenter/AssertHelper.cs
+++ b/ANX.Framework.TestCenter/AssertHelper.cs
@@ -201,7 +201,7 @@ namespace ANX.Framework.TestCenter
             return intDiff <= (1 << maxDeltaBits); 
         }
 
-        public static void CompareFloats(float xna, float anx, String test)
+        public static void ConvertEquals(float xna, float anx, String test)
         {
             if (AssertHelper.CompareFloats(xna, anx, epsilon) ||
                 (xna + epsilon >= float.MaxValue && anx + epsilon >= float.MaxValue) ||
@@ -215,7 +215,7 @@ namespace ANX.Framework.TestCenter
             }
         }
 
-        public static void CompareString(String xna, String anx, String test)
+        public static void ConvertEquals(String xna, String anx, String test)
         {
             if (xna == anx)
             {
@@ -430,18 +430,6 @@ namespace ANX.Framework.TestCenter
             }
         }
 
-        public static void ConvertEquals(float a, float b, String test)
-        {
-            if (a.Equals(b))
-            {
-                Assert.Pass(test + " passed");
-            }
-            else
-            {
-                Assert.Fail(String.Format("{0} failed: float a: ({1}) float b: ({2})", test, a, b));
-            }
-        }
-
         public static void ConvertEquals(byte a, byte b, String test)
         {
             if (a == b)
diff --git a/ANX.Framework.TestCenter/Input/GamePadDPadTest.cs b/ANX.Framework.TestCenter/Input/GamePadDPadTest.cs
index 36b00ffb..f28e62ea 100644
--- a/ANX.Framework.TestCenter/Input/GamePadDPadTest.cs
+++ b/ANX.Framework.TestCenter/Input/GamePadDPadTest.cs
@@ -142,7 +142,7 @@ namespace ANX.Framework.TestCenter.Input
             ANXGamePadDPad anx = new ANXGamePadDPad(upValue, downValue, leftValue, rightValue);
             XNAGamePadDPad xna = new XNAGamePadDPad(upValue2, downValue2, leftValue2, rightValue2);
 
-            AssertHelper.CompareString(xna.ToString(), anx.ToString(), "ToString");
+            AssertHelper.ConvertEquals(xna.ToString(), anx.ToString(), "ToString");
 
 
         }
diff --git a/ANX.Framework.TestCenter/Input/GamePadTriggersTest.cs b/ANX.Framework.TestCenter/Input/GamePadTriggersTest.cs
index 8029aa2f..bc2a8271 100644
--- a/ANX.Framework.TestCenter/Input/GamePadTriggersTest.cs
+++ b/ANX.Framework.TestCenter/Input/GamePadTriggersTest.cs
@@ -75,21 +75,21 @@ namespace ANX.Framework.TestCenter.Input
         {
             ANXGamePadTriggers anx = new ANXGamePadTriggers(leftTrigger, rightTrigger);
             XNAGamePadTriggers xna = new XNAGamePadTriggers(leftTrigger, rightTrigger);
-            AssertHelper.CompareFloats(xna.Left, anx.Left, "Left");
+            AssertHelper.ConvertEquals(xna.Left, anx.Left, "Left");
         }
         [TestCaseSource("twofloats")]
         public void Right(float leftTrigger, float rightTrigger)
         {
             ANXGamePadTriggers anx = new ANXGamePadTriggers(leftTrigger, rightTrigger);
             XNAGamePadTriggers xna = new XNAGamePadTriggers(leftTrigger, rightTrigger);
-            AssertHelper.CompareFloats(xna.Right, anx.Right, "Right");
+            AssertHelper.ConvertEquals(xna.Right, anx.Right, "Right");
         }
         [TestCaseSource("twofloats")]
         public void ToString(float leftTrigger, float rightTrigger)
         {
             ANXGamePadTriggers anx = new ANXGamePadTriggers(leftTrigger, rightTrigger);
             XNAGamePadTriggers xna = new XNAGamePadTriggers(leftTrigger, rightTrigger);
-            AssertHelper.CompareString(xna.ToString(), anx.ToString(), "ToString");
+            AssertHelper.ConvertEquals(xna.ToString(), anx.ToString(), "ToString");
         }
         [TestCaseSource("twofloats")]
         public void Equals(float leftTrigger, float rightTrigger)
diff --git a/ANX.Framework.TestCenter/Strukturen/MathHelperTest.cs b/ANX.Framework.TestCenter/Strukturen/MathHelperTest.cs
index 398cfad9..3e18330b 100644
--- a/ANX.Framework.TestCenter/Strukturen/MathHelperTest.cs
+++ b/ANX.Framework.TestCenter/Strukturen/MathHelperTest.cs
@@ -283,7 +283,7 @@ namespace ANX.Framework.TestCenter.Strukturen
         {
             float xna = XNAMath.Barycentric(value1, tangent1, value2, tangent2, amount);
             float anx = ANXMath.Barycentric(value1, tangent1, value2, tangent2, amount);
-            AssertHelper.CompareFloats(xna, anx, "Barycentric");
+            AssertHelper.ConvertEquals(xna, anx, "Barycentric");
         }
 
         [TestCaseSource("fivefloats")]
@@ -291,7 +291,7 @@ namespace ANX.Framework.TestCenter.Strukturen
         {
             float xna = XNAMath.CatmullRom(value1, tangent1, value2, tangent2, amount);
             float anx = ANXMath.CatmullRom(value1, tangent1, value2, tangent2, amount);
-            AssertHelper.CompareFloats(xna, anx, "CatmullRom");
+            AssertHelper.ConvertEquals(xna, anx, "CatmullRom");
         }
 
         [Test, TestCaseSource("threefloats")]
@@ -299,7 +299,7 @@ namespace ANX.Framework.TestCenter.Strukturen
         {
             float xna = XNAMath.Clamp(value1, value2, amount);
             float anx = ANXMath.Clamp(value1, value2, amount);
-            AssertHelper.CompareFloats(xna, anx, "Clamp");
+            AssertHelper.ConvertEquals(xna, anx, "Clamp");
         }
 
         [Test, TestCaseSource("threefloats")]
@@ -307,7 +307,7 @@ namespace ANX.Framework.TestCenter.Strukturen
         {
             float xna = XNAMath.SmoothStep(value1, value2, amount);
             float anx = ANXMath.SmoothStep(value1, value2, amount);
-            AssertHelper.CompareFloats(xna, anx, "SmoothStep");
+            AssertHelper.ConvertEquals(xna, anx, "SmoothStep");
         }
 
         [Test, TestCaseSource("threefloats")]
@@ -315,7 +315,7 @@ namespace ANX.Framework.TestCenter.Strukturen
         {
             float xna = XNAMath.Lerp(value1, value2, amount);
             float anx = ANXMath.Lerp(value1, value2, amount);
-            AssertHelper.CompareFloats(xna, anx, "Lerp");
+            AssertHelper.ConvertEquals(xna, anx, "Lerp");
         }
 
         [TestCaseSource("twofloats")]
@@ -323,7 +323,7 @@ namespace ANX.Framework.TestCenter.Strukturen
         {
             float xna = XNAMath.Distance(min, max);
             float anx = ANXMath.Distance(min, max);
-            AssertHelper.CompareFloats(xna, anx, "Distance");
+            AssertHelper.ConvertEquals(xna, anx, "Distance");
         }
 
         [TestCaseSource("twofloats")]
@@ -331,7 +331,7 @@ namespace ANX.Framework.TestCenter.Strukturen
         {
             float xna = XNAMath.Max(min, max);
             float anx = ANXMath.Max(min, max);
-            AssertHelper.CompareFloats(xna, anx, "Max");
+            AssertHelper.ConvertEquals(xna, anx, "Max");
         }
 
         [TestCaseSource("twofloats")]
@@ -339,7 +339,7 @@ namespace ANX.Framework.TestCenter.Strukturen
         {
             float xna = XNAMath.Min(min, max);
             float anx = ANXMath.Min(min, max);
-            AssertHelper.CompareFloats(xna, anx, "Min");
+            AssertHelper.ConvertEquals(xna, anx, "Min");
         }
 
         [TestCaseSource("onefloat")]
@@ -347,7 +347,7 @@ namespace ANX.Framework.TestCenter.Strukturen
         {
             float xna = XNAMath.ToDegrees(one);
             float anx = ANXMath.ToDegrees(one);
-            AssertHelper.CompareFloats(xna, anx, "ToRadians");
+            AssertHelper.ConvertEquals(xna, anx, "ToRadians");
 
         }
 
@@ -357,7 +357,7 @@ namespace ANX.Framework.TestCenter.Strukturen
             float xna = XNAMath.ToRadians(one);
             float anx = ANXMath.ToRadians(one);
 
-            AssertHelper.CompareFloats(xna, anx, "ToRadians");
+            AssertHelper.ConvertEquals(xna, anx, "ToRadians");
         }
 
         [TestCaseSource("onefloat")]
@@ -365,7 +365,7 @@ namespace ANX.Framework.TestCenter.Strukturen
         {
             float xna = XNAMath.WrapAngle(one);
             float anx = ANXMath.WrapAngle(one);
-            AssertHelper.CompareFloats(xna, anx, "WrapAngle");
+            AssertHelper.ConvertEquals(xna, anx, "WrapAngle");
         }
 
         [TestCaseSource("hermiteFloats")]
@@ -374,7 +374,7 @@ namespace ANX.Framework.TestCenter.Strukturen
             float xna = XNAMath.Hermite(value1, tangent1, value2, tangent2, amount);
             float anx = ANXMath.Hermite(value1, tangent1, value2, tangent2, amount);
 
-            AssertHelper.CompareFloats(xna, anx, "Hermite");
+            AssertHelper.ConvertEquals(xna, anx, "Hermite");
         }
     }
 }
diff --git a/ANX.Framework.TestCenter/Strukturen/MatrixTest.cs b/ANX.Framework.TestCenter/Strukturen/MatrixTest.cs
index 5620ce70..cf79448b 100644
--- a/ANX.Framework.TestCenter/Strukturen/MatrixTest.cs
+++ b/ANX.Framework.TestCenter/Strukturen/MatrixTest.cs
@@ -74,6 +74,7 @@ namespace ANX.Framework.TestCenter.Strukturen
         };
 
         #endregion
+ 
         #region Properties
         [Test]
         public void Identity()
@@ -105,7 +106,6 @@ namespace ANX.Framework.TestCenter.Strukturen
 
         #endregion // Constructors
 
-
         [Test, TestCaseSource("sixteenfloats")]
         public void MultiplyOperator(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
         {
@@ -183,6 +183,18 @@ namespace ANX.Framework.TestCenter.Strukturen
 
             AssertHelper.ConvertEquals(xnaM1 + xnaM2, anxM1 + anxM2, "AddOperator");
         }
+ 
+        [Test, TestCaseSource("sixteenfloats")]
+        public void Add(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
+        {
+            XNAMatrix xnaM1 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+            XNAMatrix xnaM2 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXMatrix anxM1 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+            ANXMatrix anxM2 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            AssertHelper.ConvertEquals(XNAMatrix.Add(xnaM1, xnaM2), ANXMatrix.Add(anxM1, anxM2), "Add");
+        }
 
         [Test, TestCaseSource("sixteenfloats")]
         public void SubtractOperator(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
@@ -196,6 +208,18 @@ namespace ANX.Framework.TestCenter.Strukturen
             AssertHelper.ConvertEquals(xnaM1 - xnaM2, anxM1 - anxM2, "SubtractOperator");
         }
 
+        [Test, TestCaseSource("sixteenfloats")]
+        public void Subtract(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
+        {
+            XNAMatrix xnaM1 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+            XNAMatrix xnaM2 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXMatrix anxM1 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+            ANXMatrix anxM2 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            AssertHelper.ConvertEquals(XNAMatrix.Subtract(xnaM1, xnaM2), ANXMatrix.Subtract(anxM1, anxM2), "Subtract");
+        }
+        
         [Test, TestCaseSource("sixteenfloats")]
         public void DivideOperator(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
         {
@@ -207,17 +231,88 @@ namespace ANX.Framework.TestCenter.Strukturen
 
             AssertHelper.ConvertEquals(xnaM1 / xnaM2, anxM1 / anxM2, "DivideOperator");
         }
+
+        [Test, TestCaseSource("sixteenfloats")]
+        public void Divide(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
+        {
+            XNAMatrix xnaM1 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+            XNAMatrix xnaM2 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXMatrix anxM1 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+            ANXMatrix anxM2 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            AssertHelper.ConvertEquals(XNAMatrix.Divide(xnaM1, xnaM2), ANXMatrix.Divide(anxM1, anxM2), "Divide");
+        }
+
+        [Test, TestCaseSource("sixteenfloats")]
+        public void Divide2(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
+        {
+            XNAMatrix xnaM1 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXMatrix anxM1 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+ 
+            float divide= DataFactory.RandomValueMinMax(float.Epsilon, 1000);
+
+            AssertHelper.ConvertEquals(XNAMatrix.Divide(xnaM1, divide), ANXMatrix.Divide(anxM1, divide), "Divide2");
+        }
+
+        [Test, TestCaseSource("sixteenfloats")]
+        public void Lerp(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
+        {
+            XNAMatrix xnaM1 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+            XNAMatrix xnaM2 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXMatrix anxM1 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+            ANXMatrix anxM2 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            float amount = DataFactory.RandomValueMinMax(float.Epsilon, 1000);
+
+            AssertHelper.ConvertEquals(XNAMatrix.Lerp(xnaM1, xnaM2, amount), ANXMatrix.Lerp(anxM1, anxM2, amount), "Lerp");
+        }
+
+        [Test, TestCaseSource("sixteenfloats")]
+        public void Equals(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
+        {
+            XNAMatrix xnaM1 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+            XNAMatrix xnaM2 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXMatrix anxM1 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+            ANXMatrix anxM2 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+
+            AssertHelper.ConvertEquals(xnaM1.Equals(xnaM2), anxM1.Equals(anxM2), "Equals");
+        }
+        
         [Test, TestCaseSource("sixteenfloats")]
         public void Invert(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
         {
             XNAMatrix xnaM1 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
-            XNAMatrix xnaM2 = new XNAMatrix();
+ 
+            ANXMatrix anxM1 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            AssertHelper.ConvertEquals(XNAMatrix.Invert(xnaM1), ANXMatrix.Invert(anxM1), "Invert");
+        }
+
+        [Test, TestCaseSource("sixteenfloats")]
+        public void ToString(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
+        {
+            XNAMatrix xnaM1 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
 
             ANXMatrix anxM1 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
-            ANXMatrix anxM2 = new ANXMatrix();
 
-            AssertHelper.ConvertEquals(xnaM2, anxM2, "DivideOperator");
+            AssertHelper.ConvertEquals(xnaM1.ToString(), anxM1.ToString(), "Invert");
         }
+
+        [Test, TestCaseSource("sixteenfloats")]
+        public void Negate(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
+        {
+            XNAMatrix xnaM1 = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXMatrix anxM1 = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            AssertHelper.ConvertEquals(XNAMatrix.Negate(xnaM1), ANXMatrix.Negate(anxM1), "Negate");
+        }
+
         [Test, TestCaseSource("sixteenfloats")]
         public void CreateRotationX(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
         {
@@ -236,7 +331,6 @@ namespace ANX.Framework.TestCenter.Strukturen
             AssertHelper.ConvertEquals(xnaMatrix, anxMatrix, "CreateRotationY");
         }
 
-
         [Test, TestCaseSource("sixteenfloats")]
         public void CreateRotationZ(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
         {