diff --git a/ANX.Framework.TestCenter/AssertHelper.cs b/ANX.Framework.TestCenter/AssertHelper.cs
index 9c7a8bc5..548bd4cc 100644
--- a/ANX.Framework.TestCenter/AssertHelper.cs
+++ b/ANX.Framework.TestCenter/AssertHelper.cs
@@ -459,10 +459,8 @@ namespace ANX.Framework.TestCenter
 
         public static void ConvertEquals(XNAVector2 xna, ANXVector2 anx, String test)
         {
-            //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
-            if (anx.X.ToString().Equals(xna.X.ToString()) && anx.Y.ToString().Equals(xna.Y.ToString()) ||
-                (CompareFloats(xna.X, anx.X, epsilon) &&
-                CompareFloats(xna.Y, anx.Y, epsilon)))
+            if (CompareFloats(xna.X, anx.X, epsilon) &&
+                CompareFloats(xna.Y, anx.Y, epsilon))
             {
                 Assert.Pass(test + " passed");
             }
@@ -474,8 +472,8 @@ namespace ANX.Framework.TestCenter
 
         public static void ConvertEquals(ANXVector2 xna, ANXVector2 anx, String test)
         {
-            //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
-            if (anx.X.ToString().Equals(anx.X.ToString()) && anx.Y.ToString().Equals(anx.Y.ToString()))
+            if (CompareFloats(xna.X, anx.X, epsilon) &&
+                CompareFloats(xna.Y, anx.Y, epsilon))
             {
                 Assert.Pass(test + " passed");
             }
@@ -485,13 +483,34 @@ namespace ANX.Framework.TestCenter
             }
         }
 
+        public static void ConvertEquals(XNAVector2[] xna, ANXVector2[] anx, String test)
+        {
+            bool result = true;
+
+            for (int i = 0; i < xna.Length; i++)
+            {
+                result = CompareFloats(xna[i].X, anx[i].X, epsilon) &&
+                            CompareFloats(xna[i].Y, anx[i].Y, epsilon);
+
+                if (!result)
+                    break;
+            }
+
+            if (result)
+            {
+                Assert.Pass(test + " passed");
+            }
+            else
+            {
+                Assert.Fail(string.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
+            }
+        }
+
         public static void ConvertEquals(XNAVector3 xna, ANXVector3 anx, String test)
         {
-            //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
-            if (anx.X.ToString().Equals(xna.X.ToString()) && anx.Y.ToString().Equals(xna.Y.ToString()) && anx.Z.ToString().Equals(xna.Z.ToString()) ||
-                (CompareFloats(xna.X, anx.X, epsilon) &&
+            if (CompareFloats(xna.X, anx.X, epsilon) &&
                 CompareFloats(xna.Y, anx.Y, epsilon) &&
-                CompareFloats(xna.Z, anx.Z, epsilon)))
+                CompareFloats(xna.Z, anx.Z, epsilon))
             {
                 Assert.Pass(test + " passed");
             }
@@ -501,14 +520,36 @@ namespace ANX.Framework.TestCenter
             }
         }
 
+        public static void ConvertEquals(XNAVector3[] xna, ANXVector3[] anx, String test)
+        {
+            bool result = true;
+
+            for (int i = 0; i < xna.Length; i++)
+            {
+                result = CompareFloats(xna[i].X, anx[i].X, epsilon) &&
+                            CompareFloats(xna[i].Y, anx[i].Y, epsilon) &&
+                            CompareFloats(xna[i].Z, anx[i].Z, epsilon);
+
+                if (!result)
+                    break;
+            }
+
+            if (result)
+            {
+                Assert.Pass(test + " passed");
+            }
+            else
+            {
+                Assert.Fail(string.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
+            }
+        }
+
         public static void ConvertEquals(XNAVector4 xna, ANXVector4 anx, String test)
         {
-            //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
-            if (anx.X.ToString().Equals(xna.X.ToString()) && anx.Y.ToString().Equals(xna.Y.ToString()) && anx.Z.ToString().Equals(xna.Z.ToString()) && anx.W.ToString().Equals(xna.W.ToString()) ||
-                (CompareFloats(xna.X, anx.X, epsilon) &&
+            if (CompareFloats(xna.X, anx.X, epsilon) &&
                 CompareFloats(xna.Y, anx.Y, epsilon) &&
                 CompareFloats(xna.Z, anx.Z, epsilon) &&
-                CompareFloats(xna.W, anx.W, epsilon)))
+                CompareFloats(xna.W, anx.W, epsilon))
             {
                 Assert.Pass(test + " passed");
             }
@@ -518,6 +559,31 @@ namespace ANX.Framework.TestCenter
             }
         }
 
+        public static void ConvertEquals(XNAVector4[] xna, ANXVector4[] anx, String test)
+        {
+            bool result = true;
+
+            for (int i = 0; i < xna.Length; i++)
+            {
+                result = CompareFloats(xna[i].X, anx[i].X, epsilon) &&
+                            CompareFloats(xna[i].Y, anx[i].Y, epsilon) &&
+                            CompareFloats(xna[i].Z, anx[i].Z, epsilon) &&
+                            CompareFloats(xna[i].Z, anx[i].W, epsilon);
+
+                if (!result)
+                    break;
+            }
+
+            if (result)
+            {
+                Assert.Pass(test + " passed");
+            }
+            else
+            {
+                Assert.Fail(string.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
+            }
+        }
+
         public static void ConvertEquals(XNABoundingBox xna, ANXBoundingBox anx, String test)
         {
             if (xna.Min.X == anx.Min.X &&
@@ -552,8 +618,10 @@ namespace ANX.Framework.TestCenter
 
         public static void ConvertEquals(XNARect xna, ANXRect anx, String test)
         {
-            //comparing string to catch "not defined" and "infinity" (which seems not to be equal)
-            if (xna.ToString().Equals(anx.ToString()))
+            if (xna.X == anx.X &&
+                xna.Y == anx.Y &&
+                xna.Width == anx.Width &&
+                xna.Height == anx.Height)
             {
                 Assert.Pass(test + " passed");
             }
diff --git a/ANX.Framework.TestCenter/Strukturen/Vector2Test.cs b/ANX.Framework.TestCenter/Strukturen/Vector2Test.cs
index 6aa2a611..af920465 100644
--- a/ANX.Framework.TestCenter/Strukturen/Vector2Test.cs
+++ b/ANX.Framework.TestCenter/Strukturen/Vector2Test.cs
@@ -12,6 +12,9 @@ using ANXVector2 = ANX.Framework.Vector2;
 using XNAMatrix = Microsoft.Xna.Framework.Matrix;
 using ANXMatrix = ANX.Framework.Matrix;
 
+using XNAQuaternion = Microsoft.Xna.Framework.Quaternion;
+using ANXQuaternion = ANX.Framework.Quaternion;
+
 #endregion // Using Statements
 
 #region License
@@ -83,6 +86,15 @@ namespace ANX.Framework.TestCenter.Strukturen
            new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue }
         };
 
+        static object[] twentytwoFloats =
+        {
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+        };
+
         #endregion
 
         #region Test
@@ -710,6 +722,184 @@ namespace ANX.Framework.TestCenter.Strukturen
             AssertHelper.ConvertEquals(xnaR, anxR, "DivideOperatorVector2");
         }
         #endregion
+        
+        #region Transformations
+        [Test, TestCaseSource("twentytwoFloats")]
+        public void TransformStaticMatrix(
+            float x, float y, float z,
+            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,
+            float nop0, float nop1, float nop2)
+        {
+            XNAVector2 xnaVector = new XNAVector2(x, y);
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector2 anxVector = new ANXVector2(x, y);
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector2 xna = XNAVector2.Transform(xnaVector, xnaMatrix);
+            ANXVector2 anx = ANXVector2.Transform(anxVector, anxMatrix);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrix");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public void TransformStaticQuaternion(
+            float x, float y, float z,
+            float xQ, float yQ, float zQ, float wQ,
+            float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11, float nop12, float nop13, float nop14)
+        {
+            XNAVector2 xnaVector = new XNAVector2(x, y);
+            XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
+
+            ANXVector2 anxVector = new ANXVector2(x, y);
+            ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
+
+            XNAVector2 xna = XNAVector2.Transform(xnaVector, xnaQuaternion);
+            ANXVector2 anx = ANXVector2.Transform(anxVector, anxQuaternion);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternion");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public static void TransformStaticMatrixToDestination(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            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)
+        {
+            XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector2[] xna = new XNAVector2[2];
+            XNAVector2.Transform(xnaVector, ref xnaMatrix, xna);
+            ANXVector2[] anx = new ANXVector2[2];
+            ANXVector2.Transform(anxVector, ref anxMatrix, anx);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestination");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public static void TransformStaticQuaternionToDestination(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            float xQ, float yQ, float zQ, float wQ,
+            float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
+        {
+            XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
+            XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
+
+            ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
+            ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
+
+            XNAVector2[] xna = new XNAVector2[2];
+            XNAVector2.Transform(xnaVector, ref xnaQuaternion, xna);
+            ANXVector2[] anx = new ANXVector2[2];
+            ANXVector2.Transform(anxVector, ref anxQuaternion, anx);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestination");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public static void TransformStaticMatrixToDestinationWithIndex(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            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)
+        {
+            XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector2[] xna = new XNAVector2[2];
+            XNAVector2.Transform(xnaVector, 1, ref xnaMatrix, xna, 1, 1);
+            ANXVector2[] anx = new ANXVector2[2];
+            ANXVector2.Transform(anxVector, 1, ref anxMatrix, anx, 1, 1);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestinationWithIndex");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public static void TransformStaticQuaternionToDestinationWithIndex(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            float xQ, float yQ, float zQ, float wQ,
+            float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
+        {
+            XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
+            XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
+
+            ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
+            ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
+
+            XNAVector2[] xna = new XNAVector2[2];
+            XNAVector2.Transform(xnaVector, 1, ref xnaQuaternion, xna, 1, 1);
+            ANXVector2[] anx = new ANXVector2[2];
+            ANXVector2.Transform(anxVector, 1, ref anxQuaternion, anx, 1, 1);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestinationWithIndex");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public void TransformNormalStatic(
+            float x, float y, float z,
+            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,
+            float nop0, float nop1, float nop2)
+        {
+            XNAVector2 xnaVector = new XNAVector2(x, y);
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector2 anxVector = new ANXVector2(x, y);
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector2 xna = XNAVector2.TransformNormal(xnaVector, xnaMatrix);
+            ANXVector2 anx = ANXVector2.TransformNormal(anxVector, anxMatrix);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformNormalStatic");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public void TransformNormalStaticToDestination(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            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)
+        {
+            XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector2[] xna = new XNAVector2[2];
+            XNAVector2.Transform(xnaVector, ref xnaMatrix, xna);
+            ANXVector2[] anx = new ANXVector2[2];
+            ANXVector2.Transform(anxVector, ref anxMatrix, anx);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformNormalStaticToDestination");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public void TransformNormalStaticToDestinationWithIndex(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            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)
+        {
+            XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector2[] xna = new XNAVector2[2];
+            XNAVector2.Transform(xnaVector, 1, ref xnaMatrix, xna, 1, 1);
+            ANXVector2[] anx = new ANXVector2[2];
+            ANXVector2.Transform(anxVector, 1, ref anxMatrix, anx, 1, 1);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformNormalStaticToDestinationWithIndex");
+        }
+        #endregion
 
         #endregion
 
diff --git a/ANX.Framework.TestCenter/Strukturen/Vector3Test.cs b/ANX.Framework.TestCenter/Strukturen/Vector3Test.cs
index 38e8b773..2a7f6118 100644
--- a/ANX.Framework.TestCenter/Strukturen/Vector3Test.cs
+++ b/ANX.Framework.TestCenter/Strukturen/Vector3Test.cs
@@ -9,6 +9,10 @@ using XNAVector2 = Microsoft.Xna.Framework.Vector2;
 using ANXVector2 = ANX.Framework.Vector2;
 using XNAVector3 = Microsoft.Xna.Framework.Vector3;
 using ANXVector3 = ANX.Framework.Vector3;
+using XNAMatrix = Microsoft.Xna.Framework.Matrix;
+using ANXMatrix = ANX.Framework.Matrix;
+using XNAQuaternion = Microsoft.Xna.Framework.Quaternion;
+using ANXQuaternion = ANX.Framework.Quaternion;
 
 using NUnit.Framework;
 
@@ -83,6 +87,15 @@ namespace ANX.Framework.TestCenter.Strukturen
            new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue}
         };
 
+        static object[] twentytwoFloats =
+        {
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+        };
+
         #endregion
 
         #region Tests
@@ -705,6 +718,184 @@ namespace ANX.Framework.TestCenter.Strukturen
             AssertHelper.ConvertEquals(xnaR, anxR, "DivideOperatorVector3");
         }
         #endregion
+        
+        #region Transformations
+        [Test, TestCaseSource("twentytwoFloats")]
+        public void TransformStaticMatrix(
+            float x, float y, float z,
+            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,
+            float nop0, float nop1, float nop2)
+        {
+            XNAVector3 xnaVector = new XNAVector3(x, y, z);
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector3 anxVector = new ANXVector3(x, y, z);
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector3 xna = XNAVector3.Transform(xnaVector, xnaMatrix);
+            ANXVector3 anx = ANXVector3.Transform(anxVector, anxMatrix);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrix");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public void TransformStaticQuaternion(
+            float x, float y, float z,
+            float xQ, float yQ, float zQ, float wQ,
+            float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11, float nop12, float nop13, float nop14)
+        {
+            XNAVector3 xnaVector = new XNAVector3(x, y, z);
+            XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
+
+            ANXVector3 anxVector = new ANXVector3(x, y, z);
+            ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
+
+            XNAVector3 xna = XNAVector3.Transform(xnaVector, xnaQuaternion);
+            ANXVector3 anx = ANXVector3.Transform(anxVector, anxQuaternion);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternion");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public static void TransformStaticMatrixToDestination(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            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)
+        {
+            XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector3[] xna = new XNAVector3[2];
+            XNAVector3.Transform(xnaVector, ref xnaMatrix, xna);
+            ANXVector3[] anx = new ANXVector3[2];
+            ANXVector3.Transform(anxVector, ref anxMatrix, anx);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestination");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public static void TransformStaticQuaternionToDestination(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            float xQ, float yQ, float zQ, float wQ,
+            float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
+        {
+            XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
+            XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
+
+            ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
+            ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
+
+            XNAVector3[] xna = new XNAVector3[2];
+            XNAVector3.Transform(xnaVector, ref xnaQuaternion, xna);
+            ANXVector3[] anx = new ANXVector3[2];
+            ANXVector3.Transform(anxVector, ref anxQuaternion, anx);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestination");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public static void TransformStaticMatrixToDestinationWithIndex(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            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)
+        {
+            XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector3[] xna = new XNAVector3[2];
+            XNAVector3.Transform(xnaVector, 1, ref xnaMatrix, xna, 1, 1);
+            ANXVector3[] anx = new ANXVector3[2];
+            ANXVector3.Transform(anxVector, 1, ref anxMatrix, anx, 1, 1);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestinationWithIndex");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public static void TransformStaticQuaternionToDestinationWithIndex(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            float xQ, float yQ, float zQ, float wQ,
+            float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
+        {
+            XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
+            XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
+
+            ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
+            ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
+
+            XNAVector3[] xna = new XNAVector3[2];
+            XNAVector3.Transform(xnaVector, 1, ref xnaQuaternion, xna, 1, 1);
+            ANXVector3[] anx = new ANXVector3[2];
+            ANXVector3.Transform(anxVector, 1, ref anxQuaternion, anx, 1, 1);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestinationWithIndex");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public void TransformNormalStatic(
+            float x, float y, float z,
+            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,
+            float nop0, float nop1, float nop2)
+        {
+            XNAVector3 xnaVector = new XNAVector3(x, y, z);
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector3 anxVector = new ANXVector3(x, y, z);
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector3 xna = XNAVector3.TransformNormal(xnaVector, xnaMatrix);
+            ANXVector3 anx = ANXVector3.TransformNormal(anxVector, anxMatrix);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformNormalStatic");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public void TransformNormalStaticToDestination(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            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)
+        {
+            XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector3[] xna = new XNAVector3[2];
+            XNAVector3.Transform(xnaVector, ref xnaMatrix, xna);
+            ANXVector3[] anx = new ANXVector3[2];
+            ANXVector3.Transform(anxVector, ref anxMatrix, anx);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformNormalStaticToDestination");
+        }
+
+        [Test, TestCaseSource("twentytwoFloats")]
+        public void TransformNormalStaticToDestinationWithIndex(
+            float x1, float y1, float z1,
+            float x2, float y2, float z2,
+            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)
+        {
+            XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector3[] xna = new XNAVector3[2];
+            XNAVector3.Transform(xnaVector, 1, ref xnaMatrix, xna, 1, 1);
+            ANXVector3[] anx = new ANXVector3[2];
+            ANXVector3.Transform(anxVector, 1, ref anxMatrix, anx, 1, 1);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformNormalStaticToDestinationWithIndex");
+        }
+        #endregion
 
         #endregion
 
diff --git a/ANX.Framework.TestCenter/Strukturen/Vector4Test.cs b/ANX.Framework.TestCenter/Strukturen/Vector4Test.cs
index e40d0c01..a3d2026f 100644
--- a/ANX.Framework.TestCenter/Strukturen/Vector4Test.cs
+++ b/ANX.Framework.TestCenter/Strukturen/Vector4Test.cs
@@ -11,6 +11,10 @@ using XNAVector3 = Microsoft.Xna.Framework.Vector3;
 using ANXVector3 = ANX.Framework.Vector3;
 using XNAVector4 = Microsoft.Xna.Framework.Vector4;
 using ANXVector4 = ANX.Framework.Vector4;
+using XNAMatrix = Microsoft.Xna.Framework.Matrix;
+using ANXMatrix = ANX.Framework.Matrix;
+using XNAQuaternion = Microsoft.Xna.Framework.Quaternion;
+using ANXQuaternion = ANX.Framework.Quaternion;
 
 using NUnit.Framework;
 
@@ -88,6 +92,14 @@ namespace ANX.Framework.TestCenter.Strukturen
            new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue}
         };
 
+        static object[] twentyfourFloats =
+        {
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+           new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
+        };
         #endregion
 
         #region Tests
@@ -664,6 +676,126 @@ namespace ANX.Framework.TestCenter.Strukturen
         }
         #endregion
 
+        #region Transformations
+        [Test, TestCaseSource("twentyfourFloats")]
+        public void TransformStaticMatrix(
+            float x, float y, float z, float w,
+            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,
+            float nop0, float nop1, float nop2, float nop3)
+        {
+            XNAVector4 xnaVector = new XNAVector4(x, y, z, w);
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector4 anxVector = new ANXVector4(x, y, z, w);
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector4 xna = XNAVector4.Transform(xnaVector, xnaMatrix);
+            ANXVector4 anx = ANXVector4.Transform(anxVector, anxMatrix);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrix");
+        }
+
+        [Test, TestCaseSource("twentyfourFloats")]
+        public void TransformStaticQuaternion(
+            float x, float y, float z, float w,
+            float xQ, float yQ, float zQ, float wQ,
+            float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11, float nop12, float nop13, float nop14, float nop15)
+        {
+            XNAVector4 xnaVector = new XNAVector4(x, y, z, w);
+            XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
+
+            ANXVector4 anxVector = new ANXVector4(x, y, z, w);
+            ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
+
+            XNAVector4 xna = XNAVector4.Transform(xnaVector, xnaQuaternion);
+            ANXVector4 anx = ANXVector4.Transform(anxVector, anxQuaternion);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternion");
+        }
+
+        [Test, TestCaseSource("twentyfourFloats")]
+        public static void TransformStaticMatrixToDestination(
+            float x1, float y1, float z1, float w1,
+            float x2, float y2, float z2, float w2,
+            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)
+        {
+            XNAVector4[] xnaVector = new XNAVector4[] { new XNAVector4(x1, y1, z1, w1), new XNAVector4(x2, y2, z2, w2) };
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector4[] anxVector = new ANXVector4[] { new ANXVector4(x1, y1, z1, w1), new ANXVector4(x2, y2, z2, w2) };
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector4[] xna = new XNAVector4[2];
+            XNAVector4.Transform(xnaVector, ref xnaMatrix, xna);
+            ANXVector4[] anx = new ANXVector4[2];
+            ANXVector4.Transform(anxVector, ref anxMatrix, anx);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestination");
+        }
+
+        [Test, TestCaseSource("twentyfourFloats")]
+        public static void TransformStaticQuaternionToDestination(
+            float x1, float y1, float z1, float w1,
+            float x2, float y2, float z2, float w2,
+            float xQ, float yQ, float zQ, float wQ,
+            float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
+        {
+            XNAVector4[] xnaVector = new XNAVector4[] { new XNAVector4(x1, y1, z1, w1), new XNAVector4(x2, y2, z2, w2) };
+            XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
+
+            ANXVector4[] anxVector = new ANXVector4[] { new ANXVector4(x1, y1, z1, w1), new ANXVector4(x2, y2, z2, w2) };
+            ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
+
+            XNAVector4[] xna = new XNAVector4[2];
+            XNAVector4.Transform(xnaVector, ref xnaQuaternion, xna);
+            ANXVector4[] anx = new ANXVector4[2];
+            ANXVector4.Transform(anxVector, ref anxQuaternion, anx);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestination");
+        }
+
+        [Test, TestCaseSource("twentyfourFloats")]
+        public static void TransformStaticMatrixToDestinationWithIndex(
+            float x1, float y1, float z1, float w1,
+            float x2, float y2, float z2, float w2,
+            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)
+        {
+            XNAVector4[] xnaVector = new XNAVector4[] { new XNAVector4(x1, y1, z1, w1), new XNAVector4(x2, y2, z2, w2) };
+            XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            ANXVector4[] anxVector = new ANXVector4[] { new ANXVector4(x1, y1, z1, w1), new ANXVector4(x2, y2, z2, w2) };
+            ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            XNAVector4[] xna = new XNAVector4[2];
+            XNAVector4.Transform(xnaVector, 1, ref xnaMatrix, xna, 1, 1);
+            ANXVector4[] anx = new ANXVector4[2];
+            ANXVector4.Transform(anxVector, 1, ref anxMatrix, anx, 1, 1);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestinationWithIndex");
+        }
+
+        [Test, TestCaseSource("twentyfourFloats")]
+        public static void TransformStaticQuaternionToDestinationWithIndex(
+            float x1, float y1, float z1, float w1,
+            float x2, float y2, float z2, float w2,
+            float xQ, float yQ, float zQ, float wQ,
+            float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
+        {
+            XNAVector4[] xnaVector = new XNAVector4[] { new XNAVector4(x1, y1, z1, w1), new XNAVector4(x2, y2, z2, w2) };
+            XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
+
+            ANXVector4[] anxVector = new ANXVector4[] { new ANXVector4(x1, y1, z1, w1), new ANXVector4(x2, y2, z2, w2) };
+            ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
+
+            XNAVector4[] xna = new XNAVector4[2];
+            XNAVector4.Transform(xnaVector, 1, ref xnaQuaternion, xna, 1, 1);
+            ANXVector4[] anx = new ANXVector4[2];
+            ANXVector4.Transform(anxVector, 1, ref anxQuaternion, anx, 1, 1);
+
+            AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestinationWithIndex");
+        }
+        #endregion
+
         #endregion
 
         //TODO: transform operations
diff --git a/ANX.Framework/Matrix.cs b/ANX.Framework/Matrix.cs
index c84159ec..abe4f0d8 100644
--- a/ANX.Framework/Matrix.cs
+++ b/ANX.Framework/Matrix.cs
@@ -1191,7 +1191,16 @@ namespace ANX.Framework
 
         public bool Decompose(out Vector3 scale, out Quaternion rotation, out Vector3 translation)
         {
-            throw new NotImplementedException();
+            scale = new Vector3(this.M11, this.M22, this.M33);
+            Quaternion.CreateFromRotationMatrix(ref this, out rotation);
+            translation = new Vector3(this.M41, this.M42, this.M43);
+
+            if (scale != Vector3.Zero &&
+                rotation != Quaternion.Identity &&
+                translation != Vector3.Zero)
+                return true;
+            else
+                return false;
         }
 
         public float Determinant()
diff --git a/ANX.Framework/Quaternion.cs b/ANX.Framework/Quaternion.cs
index 1622b48e..7f95ca0f 100644
--- a/ANX.Framework/Quaternion.cs
+++ b/ANX.Framework/Quaternion.cs
@@ -261,14 +261,18 @@ namespace ANX.Framework
 
         public static void Divide(ref Quaternion quaternion1, ref float divider, out Quaternion result)
         {
-            result = Quaternion.Multiply(quaternion1, 1.0f / divider);
+            divider = 1f / divider;
+            result.X = quaternion1.X * divider;
+            result.Y = quaternion1.Y * divider;
+            result.Z = quaternion1.Z * divider;
+            result.W = quaternion1.W * divider;
         }
+
         public static float Dot(Quaternion quaternion1, Quaternion quaternion2)
         {
-            return (quaternion1.X * quaternion2.X +
-                    quaternion1.Y * quaternion2.Y +
-                    quaternion1.Z * quaternion2.Z +
-                    quaternion1.W * quaternion2.W);
+            float result;
+            Quaternion.Dot(ref quaternion1, ref quaternion2, out result);
+            return result;
         }
 
         public static void Dot(ref Quaternion quaternion1, ref Quaternion quaternion2, out float result)
@@ -367,7 +371,6 @@ namespace ANX.Framework
             result.Y = quaternion1.Y * scaleFactor;
             result.Z = quaternion1.Z * scaleFactor;
             result.W = quaternion1.W * scaleFactor;
-
         }
 
         public static Quaternion Negate(Quaternion quaternion)
diff --git a/ANX.Framework/Vector2.cs b/ANX.Framework/Vector2.cs
index 5e660bab..53f0f816 100644
--- a/ANX.Framework/Vector2.cs
+++ b/ANX.Framework/Vector2.cs
@@ -428,8 +428,9 @@ namespace ANX.Framework
 
         public static Vector2 Transform(Vector2 position, Matrix matrix)
         {
-            return new Vector2(((position.X * matrix.M11) + (position.Y * matrix.M21)) + matrix.M41,
-                               ((position.X * matrix.M12) + (position.Y * matrix.M22)) + matrix.M42);
+            Vector2 result;
+            Transform(ref position, ref matrix, out result);
+            return result;
         }
 
         public static void Transform(ref Vector2 position, ref Matrix matrix, out Vector2 result)
@@ -440,24 +441,31 @@ namespace ANX.Framework
 
         public static Vector2 Transform(Vector2 value, Quaternion rotation)
         {
-            throw new NotImplementedException();
+            Vector2 result;
+            Transform(ref value, ref rotation, out result);
+            return result;
         }
+
         public static void Transform(ref Vector2 value, ref Quaternion rotation, out Vector2 result)
         {
             throw new NotImplementedException();
         }
+
         public static void Transform(Vector2[] sourceArray, int sourceIndex, ref Matrix matrix, Vector2[] destinationArray, int destinationIndex, int length)
         {
             throw new NotImplementedException();
         }
+
         public static void Transform(Vector2[] sourceArray, int sourceIndex, ref Quaternion rotation, Vector2[] destinationArray, int destinationIndex, int length)
         {
             throw new NotImplementedException();
         }
+
         public static void Transform(Vector2[] sourceArray, ref Matrix matrix, Vector2[] destinationArray)
         {
             throw new NotImplementedException();
         }
+
         public static void Transform(Vector2[] sourceArray, ref Quaternion rotation, Vector2[] destinationArray)
         {
             throw new NotImplementedException();