Большая реорганизация проекта

BasicGeometry/AngleFP32.cs

@@ -23,18 +23,18 @@ using System;
 
 namespace BasicGeometry
 {
-    public static class FP32Angle
+    public static class AngleFP32
     {
         public static float ToRadians(float angle, AngleUnit unit)
         {
             if (unit == AngleUnit.DEGREES)
             {
-                return angle * FP32Degrees.RADIANS_IN_DEGREE;
+                return angle * DegreeFP32.RADIANS_IN_DEGREE;
             }
 
             if (unit == AngleUnit.TURNS)
             {
-                return angle * FP32Radians.TWO_PI;
+                return angle * RadianFP32.TWO_PI;
             }
 
             return angle;
@@ -44,7 +44,7 @@ namespace BasicGeometry
         {
             if (unit == AngleUnit.RADIANS)
             {
-                return angle * FP32Radians.DEGREES_IN_RADIAN;
+                return angle * RadianFP32.DEGREES_IN_RADIAN;
             }
 
             if (unit == AngleUnit.TURNS)
@@ -59,12 +59,12 @@ namespace BasicGeometry
         {
             if (unit == AngleUnit.RADIANS)
             {
-                return angle * FP32Radians.TURNS_IN_RADIAN;
+                return angle * RadianFP32.TURNS_IN_RADIAN;
             }
 
             if (unit == AngleUnit.DEGREES)
             {
-                return angle * FP32Degrees.TURNS_IN_DEGREE;
+                return angle * DegreeFP32.TURNS_IN_DEGREE;
             }
 
             return angle;
@@ -82,7 +82,7 @@ namespace BasicGeometry
                 return 1.0f;
             }
 
-            return FP32Radians.TWO_PI;
+            return RadianFP32.TWO_PI;
         }
     
         public static float GetHalfCircle(AngleUnit unit)
@@ -97,7 +97,7 @@ namespace BasicGeometry
                 return 0.5f;
             }
 
-            return FP32Radians.PI;
+            return RadianFP32.PI;
         }
     
         public static float GetQuarterCircle(AngleUnit unit)
@@ -112,22 +112,22 @@ namespace BasicGeometry
                 return 0.25f;
             }
 
-            return FP32Radians.HALF_OF_PI;
+            return RadianFP32.HALF_OF_PI;
         }
 
         public static float Normalize(float angle, AngleUnit unit, AngleRange range)
         {
             if (unit == AngleUnit.DEGREES)
             {
-                return FP32Degrees.Normalize(angle, range);
+                return DegreeFP32.Normalize(angle, range);
             }
 
             if (unit == AngleUnit.TURNS)
             {
-                return FP32Turns.Normalize(angle, range);
+                return TurnFP32.Normalize(angle, range);
             }
 
-            return FP32Radians.Normalize(angle, range);
+            return RadianFP32.Normalize(angle, range);
         }
     }
 }

BasicGeometry/AngleFP64.cs

@@ -23,18 +23,18 @@ using System;
 
 namespace BasicGeometry
 {
-    public static class FP64Angle
+    public static class AngleFP64
     {
         public static double ToRadians(double angle, AngleUnit unit)
         {
             if (unit == AngleUnit.DEGREES)
             {
-                return angle * FP64Degrees.RADIANS_IN_DEGREE;
+                return angle * DegreeFP64.RADIANS_IN_DEGREE;
             }
 
             if (unit == AngleUnit.TURNS)
             {
-                return angle * FP64Radians.TWO_PI;
+                return angle * RadianFP64.TWO_PI;
             }
 
             return angle;
@@ -44,7 +44,7 @@ namespace BasicGeometry
         {
             if (unit == AngleUnit.RADIANS)
             {
-                return angle * FP64Radians.DEGREES_IN_RADIAN;
+                return angle * RadianFP64.DEGREES_IN_RADIAN;
             }
 
             if (unit == AngleUnit.TURNS)
@@ -59,12 +59,12 @@ namespace BasicGeometry
         {
             if (unit == AngleUnit.RADIANS)
             {
-                return angle * FP64Radians.TURNS_IN_RADIAN;
+                return angle * RadianFP64.TURNS_IN_RADIAN;
             }
 
             if (unit == AngleUnit.DEGREES)
             {
-                return angle * FP64Degrees.TURNS_IN_DEGREE;
+                return angle * DegreeFP64.TURNS_IN_DEGREE;
             }
 
             return angle;
@@ -82,7 +82,7 @@ namespace BasicGeometry
                 return 1.0;
             }
 
-            return FP64Radians.TWO_PI;
+            return RadianFP64.TWO_PI;
         }
     
         public static double GetHalfCircle(AngleUnit unit)
@@ -97,7 +97,7 @@ namespace BasicGeometry
                 return 0.5;
             }
 
-            return FP64Radians.PI;
+            return RadianFP64.PI;
         }
     
         public static double GetQuarterCircle(AngleUnit unit)
@@ -112,22 +112,22 @@ namespace BasicGeometry
                 return 0.25;
             }
 
-            return FP64Radians.HALF_OF_PI;
+            return RadianFP64.HALF_OF_PI;
         }
 
         public static double Normalize(double angle, AngleUnit unit, AngleRange range)
         {
             if (unit == AngleUnit.DEGREES)
             {
-                return FP64Degrees.Normalize(angle, range);
+                return DegreeFP64.Normalize(angle, range);
             }
 
             if (unit == AngleUnit.TURNS)
             {
-                return FP64Turns.Normalize(angle, range);
+                return TurnFP64.Normalize(angle, range);
             }
 
-            return FP64Radians.Normalize(angle, range);
+            return RadianFP64.Normalize(angle, range);
         }
     }
 }

BasicGeometry/DegreeFP32.cs

@@ -6,7 +6,7 @@
 
 namespace BasicGeometry
 {
-    public class FP32Degrees
+    public class DegreeFP32
     {
         public const float RADIANS_IN_DEGREE = 1.745329252E-2f;
         public const float TURNS_IN_DEGREE = 2.7777777778E-3f;

BasicGeometry/DegreeFP64.cs

@@ -6,7 +6,7 @@
 
 namespace BasicGeometry
 {
-    public class FP64Degrees
+    public class DegreeFP64
     {
         public const double RADIANS_IN_DEGREE = 1.74532925199432958E-2;
         public const double TURNS_IN_DEGREE = 2.77777777777777778E-3;

BasicGeometry/FP32Utility.cs

@@ -1,21 +0,0 @@
-using System;
-
-namespace BasicGeometry
-{
-    public class FP32Utility
-    {
-        public const float EPSYLON = 5E-7f;
-        public const float TWO_EPSYLON = 1E-6f;
-        public const float SQUARE_EPSYLON = 2.5E-13f;
-        
-        public const float EPSYLON_EFFECTIVENESS_LIMIT = 1.0f;
-
-        public const float ONE_THIRD = 0.333333333f;
-        public const float ONE_SIXTH = 0.166666667f;
-        public const float ONE_NINETH = 0.111111111f;
-
-        public const float GOLDEN_RATIO_HIGH = 1.618034f;
-        public const float GOLDEN_RATIO_LOW = 0.618034f;
-    }
-}
-

BasicGeometry/FP64Utility.cs

@@ -1,20 +0,0 @@
-using System;
-
-namespace BasicGeometry
-{
-    public class FP64Utility
-    {
-        public const double EPSYLON = 5E-14;
-        public const double TWO_EPSYLON = 1E-13;
-        public const double SQUARE_EPSYLON = 2.5E-27;
-        
-        public const double EPSYLON_EFFECTIVENESS_LIMIT = 1.0;
-
-        public const double ONE_THIRD = 0.333333333333333333;
-        public const double ONE_SIXTH = 0.166666666666666667;
-        public const double ONE_NINETH = 0.111111111111111111;
-
-        public const double GOLDEN_RATIO_HIGH = 1.61803398874989485;
-        public const double GOLDEN_RATIO_LOW = 0.61803398874989485;
-    }
-}

BasicGeometry/Matrix2x2FP32.cs

@@ -23,18 +23,18 @@ using System;
 
 namespace BasicGeometry
 {
-    public struct FP32Matrix2x2
+    public struct Matrix2x2FP32
     {
         public float r1c1 = 0.0f, r1c2 = 0.0f;
         public float r2c1 = 0.0f, r2c2 = 0.0f;
 
-        public FP32Matrix2x2(float d1, float d2)
+        public Matrix2x2FP32(float d1, float d2)
         {
             this.r1c1 = d1;
             this.r2c2 = d2;
         }
 
-        public FP32Matrix2x2(in FP32Matrix2x2 matrix)
+        public Matrix2x2FP32(in Matrix2x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -43,7 +43,7 @@ namespace BasicGeometry
             this.r2c2 = matrix.r2c2;
         }
 
-        public FP32Matrix2x2(in FP64Matrix2x2 matrix)
+        public Matrix2x2FP32(in Matrix2x2FP64 matrix)
         {
             this.r1c1 = (float)matrix.r1c1;
             this.r1c2 = (float)matrix.r1c2;
@@ -60,7 +60,7 @@ namespace BasicGeometry
         public readonly bool IsSingular()
         {
             float determinant = this.GetDeterminant();
-            return -FP32Utility.EPSYLON <= determinant && determinant <= FP32Utility.EPSYLON;
+            return -UtilityFP32.EPSYLON <= determinant && determinant <= UtilityFP32.EPSYLON;
         }
 
         public void Transpose()
@@ -72,7 +72,7 @@ namespace BasicGeometry
         {
             float determinant = this.GetDeterminant();
 
-            if (-FP32Utility.EPSYLON <= determinant && determinant <= FP32Utility.EPSYLON)
+            if (-UtilityFP32.EPSYLON <= determinant && determinant <= UtilityFP32.EPSYLON)
             {
                 return false;
             }
@@ -121,7 +121,7 @@ namespace BasicGeometry
             this.r2c2 = d2;
         }
 
-        public void SetValues(in FP32Matrix2x2 matrix)
+        public void SetValues(in Matrix2x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -130,7 +130,7 @@ namespace BasicGeometry
             this.r2c2 = matrix.r2c2;
         }
 
-        public void SetValues(in FP64Matrix2x2 matrix)
+        public void SetValues(in Matrix2x2FP64 matrix)
         {
             this.r1c1 = (float)matrix.r1c1;
             this.r1c2 = (float)matrix.r1c2;
@@ -139,14 +139,14 @@ namespace BasicGeometry
             this.r2c2 = (float)matrix.r2c2;
         }
 
-        public void SetTransposedOf(in FP32Matrix2x2 matrix)
+        public void SetTransposedOf(in Matrix2x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r2c2 = matrix.r2c2;
             (this.r1c2, this.r2c1) = (matrix.r2c1, matrix.r1c2);
         }
 
-        public void SetTransposedOf(in FP64Matrix2x2 matrix)
+        public void SetTransposedOf(in Matrix2x2FP64 matrix)
         {
             this.r1c1 = (float)matrix.r1c1;
             this.r1c2 = (float)matrix.r2c1;
@@ -155,11 +155,11 @@ namespace BasicGeometry
             this.r2c2 = (float)matrix.r2c2;
         }
 
-        public bool SetInvertedOf(in FP32Matrix2x2 matrix)
+        public bool SetInvertedOf(in Matrix2x2FP32 matrix)
         {
             float determinant = matrix.GetDeterminant();
 
-            if (-FP32Utility.EPSYLON <= determinant && determinant <= FP32Utility.EPSYLON)
+            if (-UtilityFP32.EPSYLON <= determinant && determinant <= UtilityFP32.EPSYLON)
             {
                 return false;
             }
@@ -205,7 +205,7 @@ namespace BasicGeometry
             this.r2c2 = r2;
         }
 
-        public void AppendScaled(in FP32Matrix2x2 matrix, float scale)
+        public void AppendScaled(in Matrix2x2FP32 matrix, float scale)
         {
             this.r1c1 += matrix.r1c1 * scale;
             this.r1c2 += matrix.r1c2 * scale;
@@ -214,7 +214,7 @@ namespace BasicGeometry
             this.r2c2 += matrix.r2c2 * scale;
         }
 
-        public static void Add(in FP32Matrix2x2 matrix1, in FP32Matrix2x2 matrix2, out FP32Matrix2x2 result)
+        public static void Add(in Matrix2x2FP32 matrix1, in Matrix2x2FP32 matrix2, out Matrix2x2FP32 result)
         {
             result.r1c1 = matrix1.r1c1 + matrix2.r1c1;
             result.r1c2 = matrix1.r1c2 + matrix2.r1c2;
@@ -223,7 +223,7 @@ namespace BasicGeometry
             result.r2c2 = matrix1.r2c2 + matrix2.r2c2;
         }
 
-        public static void Subtract(in FP32Matrix2x2 minuend, in FP32Matrix2x2 subtrahend, out FP32Matrix2x2 difference)
+        public static void Subtract(in Matrix2x2FP32 minuend, in Matrix2x2FP32 subtrahend, out Matrix2x2FP32 difference)
         {
             difference.r1c1 = minuend.r1c1 - subtrahend.r1c1;
             difference.r1c2 = minuend.r1c2 - subtrahend.r1c2;
@@ -232,7 +232,7 @@ namespace BasicGeometry
             difference.r2c2 = minuend.r2c2 - subtrahend.r2c2;
         }
 
-        public static void Multiply(in FP32Matrix2x2 multiplicand, float multiplier, out FP32Matrix2x2 product)
+        public static void Multiply(in Matrix2x2FP32 multiplicand, float multiplier, out Matrix2x2FP32 product)
         {
             product.r1c1 = multiplicand.r1c1 * multiplier;
             product.r1c2 = multiplicand.r1c2 * multiplier;
@@ -241,12 +241,12 @@ namespace BasicGeometry
             product.r2c2 = multiplicand.r2c2 * multiplier;
         }
 
-        public static void Divide(in FP32Matrix2x2 dividend, float divisor, out FP32Matrix2x2 quotient)
+        public static void Divide(in Matrix2x2FP32 dividend, float divisor, out Matrix2x2FP32 quotient)
         {
             Multiply(dividend, 1.0f / divisor, out quotient);
         }
 
-        public static void GetRightProduct(in FP32Matrix2x2 matrix, in FP32Vector2 vector, out FP32Vector2 result)
+        public static void GetRightProduct(in Matrix2x2FP32 matrix, in Vector2FP32 vector, out Vector2FP32 result)
         {
             float x1 = matrix.r1c1 * vector.x1 + matrix.r1c2 * vector.x2;
             float x2 = matrix.r2c1 * vector.x1 + matrix.r2c2 * vector.x2;
@@ -255,7 +255,7 @@ namespace BasicGeometry
             result.x2 = x2;
         }
 
-        public static void GetLeftProduct(in FP32Vector2 vector, in FP32Matrix2x2 matrix, out FP32Vector2 result)
+        public static void GetLeftProduct(in Vector2FP32 vector, in Matrix2x2FP32 matrix, out Vector2FP32 result)
         {
             float x1 = vector.x1 * matrix.r1c1 + vector.x2 * matrix.r2c1;
             float x2 = vector.x1 * matrix.r1c2 + vector.x2 * matrix.r2c2;
@@ -264,7 +264,7 @@ namespace BasicGeometry
             result.x2 = x2;
         }
 
-        public static void LoadZero(out FP32Matrix2x2 matrix)
+        public static void LoadZero(out Matrix2x2FP32 matrix)
         {
             matrix.r1c1 = 0.0f;
             matrix.r1c2 = 0.0f;
@@ -273,7 +273,7 @@ namespace BasicGeometry
             matrix.r2c2 = 0.0f;
         }
 
-        public static void LoadIdentity(out FP32Matrix2x2 matrix)
+        public static void LoadIdentity(out Matrix2x2FP32 matrix)
         {
             matrix.r1c1 = 1.0f;
             matrix.r1c2 = 0.0f;
@@ -282,7 +282,7 @@ namespace BasicGeometry
             matrix.r2c2 = 1.0f;
         }
 
-        public static void LoadDiagonal(float d1, float d2, out FP32Matrix2x2 matrix)
+        public static void LoadDiagonal(float d1, float d2, out Matrix2x2FP32 matrix)
         {
             matrix.r1c1 = d1;
             matrix.r1c2 = 0.0f;

BasicGeometry/Matrix2x2FP64.cs

@@ -23,18 +23,18 @@ using System;
 
 namespace BasicGeometry
 {
-    public struct FP64Matrix2x2
+    public struct Matrix2x2FP64
     {
         public double r1c1 = 0.0, r1c2 = 0.0;
         public double r2c1 = 0.0, r2c2 = 0.0;
 
-        public FP64Matrix2x2(double d1, double d2)
+        public Matrix2x2FP64(double d1, double d2)
         {
             this.r1c1 = d1;
             this.r2c2 = d2;
         }
 
-        public FP64Matrix2x2(in FP64Matrix2x2 matrix)
+        public Matrix2x2FP64(in Matrix2x2FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -43,7 +43,7 @@ namespace BasicGeometry
             this.r2c2 = matrix.r2c2;
         }
 
-        public FP64Matrix2x2(in FP32Matrix2x2 matrix)
+        public Matrix2x2FP64(in Matrix2x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -60,7 +60,7 @@ namespace BasicGeometry
         public readonly bool IsSingular()
         {
             double determinant = this.GetDeterminant();
-            return -FP64Utility.EPSYLON <= determinant && determinant <= FP64Utility.EPSYLON;
+            return -UtilityFP64.EPSYLON <= determinant && determinant <= UtilityFP64.EPSYLON;
         }
 
         public void Transpose()
@@ -72,7 +72,7 @@ namespace BasicGeometry
         {
             double determinant = this.GetDeterminant();
 
-            if (-FP64Utility.EPSYLON <= determinant && determinant <= FP64Utility.EPSYLON)
+            if (-UtilityFP64.EPSYLON <= determinant && determinant <= UtilityFP64.EPSYLON)
             {
                 return false;
             }
@@ -121,7 +121,7 @@ namespace BasicGeometry
             this.r2c2 = d2;
         }
 
-        public void SetValues(in FP64Matrix2x2 matrix)
+        public void SetValues(in Matrix2x2FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -130,7 +130,7 @@ namespace BasicGeometry
             this.r2c2 = matrix.r2c2;
         }
 
-        public void SetValues(in FP32Matrix2x2 matrix)
+        public void SetValues(in Matrix2x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -139,14 +139,14 @@ namespace BasicGeometry
             this.r2c2 = matrix.r2c2;
         }
 
-        public void SetTransposedOf(in FP64Matrix2x2 matrix)
+        public void SetTransposedOf(in Matrix2x2FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r2c2 = matrix.r2c2;
             (this.r1c2, this.r2c1) = (matrix.r2c1, matrix.r1c2);
         }
 
-        public void SetTransposedOf(in FP32Matrix2x2 matrix)
+        public void SetTransposedOf(in Matrix2x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -155,11 +155,11 @@ namespace BasicGeometry
             this.r2c2 = matrix.r2c2;
         }
 
-        public bool SetInvertedOf(in FP64Matrix2x2 matrix)
+        public bool SetInvertedOf(in Matrix2x2FP64 matrix)
         {
             double determinant = matrix.GetDeterminant();
 
-            if (-FP64Utility.EPSYLON <= determinant && determinant <= FP64Utility.EPSYLON)
+            if (-UtilityFP64.EPSYLON <= determinant && determinant <= UtilityFP64.EPSYLON)
             {
                 return false;
             }
@@ -205,7 +205,7 @@ namespace BasicGeometry
             this.r2c2 = r2;
         }
 
-        public void AppendScaled(in FP64Matrix2x2 matrix, double scale)
+        public void AppendScaled(in Matrix2x2FP64 matrix, double scale)
         {
             this.r1c1 += matrix.r1c1 * scale;
             this.r1c2 += matrix.r1c2 * scale;
@@ -214,7 +214,7 @@ namespace BasicGeometry
             this.r2c2 += matrix.r2c2 * scale;
         }
 
-        public static void Add(in FP64Matrix2x2 matrix1, in FP64Matrix2x2 matrix2, out FP64Matrix2x2 sum)
+        public static void Add(in Matrix2x2FP64 matrix1, in Matrix2x2FP64 matrix2, out Matrix2x2FP64 sum)
         {
             sum.r1c1 = matrix1.r1c1 + matrix2.r1c1;
             sum.r1c2 = matrix1.r1c2 + matrix2.r1c2;
@@ -223,7 +223,7 @@ namespace BasicGeometry
             sum.r2c2 = matrix1.r2c2 + matrix2.r2c2;
         }
 
-        public static void Subtract(in FP64Matrix2x2 minuend, in FP64Matrix2x2 subtrahend, out FP64Matrix2x2 difference)
+        public static void Subtract(in Matrix2x2FP64 minuend, in Matrix2x2FP64 subtrahend, out Matrix2x2FP64 difference)
         {
             difference.r1c1 = minuend.r1c1 - subtrahend.r1c1;
             difference.r1c2 = minuend.r1c2 - subtrahend.r1c2;
@@ -232,7 +232,7 @@ namespace BasicGeometry
             difference.r2c2 = minuend.r2c2 - subtrahend.r2c2;
         }
 
-        public static void Multiply(in FP64Matrix2x2 multiplicand, double multiplier, out FP64Matrix2x2 product)
+        public static void Multiply(in Matrix2x2FP64 multiplicand, double multiplier, out Matrix2x2FP64 product)
         {
             product.r1c1 = multiplicand.r1c1 * multiplier;
             product.r1c2 = multiplicand.r1c2 * multiplier;
@@ -241,12 +241,12 @@ namespace BasicGeometry
             product.r2c2 = multiplicand.r2c2 * multiplier;
         }
 
-        public static void Divide(in FP64Matrix2x2 dividend, double divisor, out FP64Matrix2x2 quotient)
+        public static void Divide(in Matrix2x2FP64 dividend, double divisor, out Matrix2x2FP64 quotient)
         {
             Multiply(dividend, 1.0 / divisor, out quotient);
         }
 
-        public static void GetRightProduct(in FP64Matrix2x2 matrix, in FP64Vector2 vector, out FP64Vector2 result)
+        public static void GetRightProduct(in Matrix2x2FP64 matrix, in Vector2FP64 vector, out Vector2FP64 result)
         {
             double x1 = matrix.r1c1 * vector.x1 + matrix.r1c2 * vector.x2;
             double x2 = matrix.r2c1 * vector.x1 + matrix.r2c2 * vector.x2;
@@ -255,7 +255,7 @@ namespace BasicGeometry
             result.x2 = x2;
         }
 
-        public static void GetLeftProduct(in FP64Vector2 vector, in FP64Matrix2x2 matrix, out FP64Vector2 result)
+        public static void GetLeftProduct(in Vector2FP64 vector, in Matrix2x2FP64 matrix, out Vector2FP64 result)
         {
             double x1 = vector.x1 * matrix.r1c1 + vector.x2 * matrix.r2c1;
             double x2 = vector.x1 * matrix.r1c2 + vector.x2 * matrix.r2c2;
@@ -264,7 +264,7 @@ namespace BasicGeometry
             result.x2 = x2;
         }
 
-        public static void LoadZero(out FP64Matrix2x2 matrix)
+        public static void LoadZero(out Matrix2x2FP64 matrix)
         {
             matrix.r1c1 = 0.0;
             matrix.r1c2 = 0.0;
@@ -273,7 +273,7 @@ namespace BasicGeometry
             matrix.r2c2 = 0.0;
         }
 
-        public static void LoadIdentity(out FP64Matrix2x2 matrix)
+        public static void LoadIdentity(out Matrix2x2FP64 matrix)
         {
             matrix.r1c1 = 1.0;
             matrix.r1c2 = 0.0;
@@ -282,7 +282,7 @@ namespace BasicGeometry
             matrix.r2c2 = 1.0;
         }
 
-        public static void LoadDiagonal(double d1, double d2, out FP64Matrix2x2 matrix)
+        public static void LoadDiagonal(double d1, double d2, out Matrix2x2FP64 matrix)
         {
             matrix.r1c1 = d1;
             matrix.r1c2 = 0.0;

BasicGeometry/Matrix2x3FP32.cs

@@ -22,13 +22,13 @@ using System;
  */
 namespace BasicGeometry
 {
-    public struct FP32Matrix2x3
+    public struct Matrix2x3FP32
     {
         public float r1c1 = 0.0f, r1c2 = 0.0f;
         public float r2c1 = 0.0f, r2c2 = 0.0f;
         public float r3c1 = 0.0f, r3c2 = 0.0f;
     
-        public FP32Matrix2x3(in FP32Matrix2x3 matrix)
+        public Matrix2x3FP32(in Matrix2x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -40,7 +40,7 @@ namespace BasicGeometry
             this.r3c2 = matrix.r3c2;
         }
     
-        public FP32Matrix2x3(in FP64Matrix2x3 matrix)
+        public Matrix2x3FP32(in Matrix2x3FP64 matrix)
         {
             this.r1c1 = (float) matrix.r1c1;
             this.r1c2 = (float) matrix.r1c2;
@@ -52,7 +52,7 @@ namespace BasicGeometry
             this.r3c2 = (float) matrix.r3c2;
         }
     
-        public FP32Matrix2x3(in FP32Matrix3x2 matrix)
+        public Matrix2x3FP32(in Matrix3x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -64,7 +64,7 @@ namespace BasicGeometry
             this.r3c2 = matrix.r2c3;
         }
     
-        public FP32Matrix2x3(in FP64Matrix3x2 matrix)
+        public Matrix2x3FP32(in Matrix3x2FP64 matrix)
         {
             this.r1c1 = (float) matrix.r1c1;
             this.r1c2 = (float) matrix.r2c1;
@@ -88,7 +88,7 @@ namespace BasicGeometry
             this.r3c2 = 0.0f;
         }
     
-        public void SetValues(in FP32Matrix2x3 matrix)
+        public void SetValues(in Matrix2x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -100,7 +100,7 @@ namespace BasicGeometry
             this.r3c2 = matrix.r3c2;
         }
     
-        public void SetValues(in FP64Matrix2x3 matrix)
+        public void SetValues(in Matrix2x3FP64 matrix)
         {
             this.r1c1 = (float) matrix.r1c1;
             this.r1c2 = (float) matrix.r1c2;
@@ -112,7 +112,7 @@ namespace BasicGeometry
             this.r3c2 = (float) matrix.r3c2;
         }
     
-        public void SetTransposed(in FP32Matrix3x2 matrix)
+        public void SetTransposed(in Matrix3x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -124,7 +124,7 @@ namespace BasicGeometry
             this.r3c2 = matrix.r2c3;
         }
     
-        public void SetTransposed(in FP64Matrix3x2 matrix)
+        public void SetTransposed(in Matrix3x2FP64 matrix)
         {
             this.r1c1 = (float) matrix.r1c1;
             this.r1c2 = (float) matrix.r2c1;
@@ -168,7 +168,7 @@ namespace BasicGeometry
             this.r3c2 = r3;
         }
 
-        public void AppendScaled(in FP32Matrix2x3 matrix, float scale)
+        public void AppendScaled(in Matrix2x3FP32 matrix, float scale)
         {
             this.r1c1 += matrix.r1c1 * scale;
             this.r1c2 += matrix.r1c2 * scale;
@@ -180,7 +180,7 @@ namespace BasicGeometry
             this.r3c2 += matrix.r3c2 * scale;
         }
 
-        public static void Add(in FP32Matrix2x3 matrix1, in FP32Matrix2x3 matrix2, out FP32Matrix2x3 sum)
+        public static void Add(in Matrix2x3FP32 matrix1, in Matrix2x3FP32 matrix2, out Matrix2x3FP32 sum)
         {
             sum.r1c1 = matrix1.r1c1 + matrix2.r1c1;
             sum.r1c2 = matrix1.r1c2 + matrix2.r1c2;
@@ -192,7 +192,7 @@ namespace BasicGeometry
             sum.r3c2 = matrix1.r3c2 + matrix2.r3c2;
         }
 
-        public static void Subtract(in FP32Matrix2x3 minuend, in FP32Matrix2x3 subtrahend, out FP32Matrix2x3 difference)
+        public static void Subtract(in Matrix2x3FP32 minuend, in Matrix2x3FP32 subtrahend, out Matrix2x3FP32 difference)
         {
             difference.r1c1 = minuend.r1c1 - subtrahend.r1c1;
             difference.r1c2 = minuend.r1c2 - subtrahend.r1c2;
@@ -204,7 +204,7 @@ namespace BasicGeometry
             difference.r3c2 = minuend.r3c2 - subtrahend.r3c2;
         }
 
-        public static void Multiply(in FP32Matrix2x3 multiplicand, float multiplier, out FP32Matrix2x3 product)
+        public static void Multiply(in Matrix2x3FP32 multiplicand, float multiplier, out Matrix2x3FP32 product)
         {
             product.r1c1 = multiplicand.r1c1 * multiplier;
             product.r1c2 = multiplicand.r1c2 * multiplier;
@@ -216,19 +216,19 @@ namespace BasicGeometry
             product.r3c2 = multiplicand.r3c2 * multiplier;
         }
 
-        public static void Divide(in FP32Matrix2x3 dividend, float divisor, out FP32Matrix2x3 quotient)
+        public static void Divide(in Matrix2x3FP32 dividend, float divisor, out Matrix2x3FP32 quotient)
         {
             Multiply(dividend, 1.0f / divisor, out quotient);
         }
 
-        public static void GetRightProduct(in FP32Matrix2x3 matrix, in FP32Vector2 vector, out FP32Vector3 result)
+        public static void GetRightProduct(in Matrix2x3FP32 matrix, in Vector2FP32 vector, out Vector3FP32 result)
         {
             result.x1 = matrix.r1c1 * vector.x1 + matrix.r1c2 * vector.x2;
             result.x2 = matrix.r2c1 * vector.x1 + matrix.r2c2 * vector.x2;
             result.x3 = matrix.r3c1 * vector.x1 + matrix.r3c2 * vector.x2;
         }
 
-        public static void GetLeftProduct(in FP32Vector3 vector, in FP32Matrix2x3 matrix, out FP32Vector2 result)
+        public static void GetLeftProduct(in Vector3FP32 vector, in Matrix2x3FP32 matrix, out Vector2FP32 result)
         {
             result.x1 = vector.x1 * matrix.r1c1 + vector.x2 * matrix.r2c1 + vector.x3 * matrix.r3c1;
             result.x2 = vector.x1 * matrix.r1c2 + vector.x2 * matrix.r2c2 + vector.x3 * matrix.r3c2;

BasicGeometry/Matrix2x3FP64.cs

@@ -22,13 +22,13 @@ using System;
  */
 namespace BasicGeometry
 {
-    public struct FP64Matrix2x3
+    public struct Matrix2x3FP64
     {
         public double r1c1 = 0.0, r1c2 = 0.0;
         public double r2c1 = 0.0, r2c2 = 0.0;
         public double r3c1 = 0.0, r3c2 = 0.0;
     
-        public FP64Matrix2x3(in FP64Matrix2x3 matrix)
+        public Matrix2x3FP64(in Matrix2x3FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -40,7 +40,7 @@ namespace BasicGeometry
             this.r3c2 = matrix.r3c2;
         }
     
-        public FP64Matrix2x3(in FP32Matrix2x3 matrix)
+        public Matrix2x3FP64(in Matrix2x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -52,7 +52,7 @@ namespace BasicGeometry
             this.r3c2 = matrix.r3c2;
         }
     
-        public FP64Matrix2x3(in FP64Matrix3x2 matrix)
+        public Matrix2x3FP64(in Matrix3x2FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -64,7 +64,7 @@ namespace BasicGeometry
             this.r3c2 = matrix.r2c3;
         }
     
-        public FP64Matrix2x3(in FP32Matrix3x2 matrix)
+        public Matrix2x3FP64(in Matrix3x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -88,7 +88,7 @@ namespace BasicGeometry
             this.r3c2 = 0.0;
         }
     
-        public void SetValues(in FP64Matrix2x3 matrix)
+        public void SetValues(in Matrix2x3FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -100,7 +100,7 @@ namespace BasicGeometry
             this.r3c2 = matrix.r3c2;
         }
     
-        public void SetValues(in FP32Matrix2x3 matrix)
+        public void SetValues(in Matrix2x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -112,7 +112,7 @@ namespace BasicGeometry
             this.r3c2 = matrix.r3c2;
         }
     
-        public void SetTransposed(in FP64Matrix3x2 matrix)
+        public void SetTransposed(in Matrix3x2FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -124,7 +124,7 @@ namespace BasicGeometry
             this.r3c2 = matrix.r2c3;
         }
     
-        public void SetTransposed(in FP32Matrix3x2 matrix)
+        public void SetTransposed(in Matrix3x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -168,7 +168,7 @@ namespace BasicGeometry
             this.r3c2 = r3;
         }
 
-        public void AppendScaled(in FP64Matrix2x3 matrix, double scale)
+        public void AppendScaled(in Matrix2x3FP64 matrix, double scale)
         {
             this.r1c1 += matrix.r1c1 * scale;
             this.r1c2 += matrix.r1c2 * scale;
@@ -180,7 +180,7 @@ namespace BasicGeometry
             this.r3c2 += matrix.r3c2 * scale;
         }
 
-        public static void Add(in FP64Matrix2x3 matrix1, in FP64Matrix2x3 matrix2, out FP64Matrix2x3 sum)
+        public static void Add(in Matrix2x3FP64 matrix1, in Matrix2x3FP64 matrix2, out Matrix2x3FP64 sum)
         {
             sum.r1c1 = matrix1.r1c1 + matrix2.r1c1;
             sum.r1c2 = matrix1.r1c2 + matrix2.r1c2;
@@ -192,7 +192,7 @@ namespace BasicGeometry
             sum.r3c2 = matrix1.r3c2 + matrix2.r3c2;
         }
 
-        public static void Subtract(in FP64Matrix2x3 minuend, in FP64Matrix2x3 subtrahend, out FP64Matrix2x3 difference)
+        public static void Subtract(in Matrix2x3FP64 minuend, in Matrix2x3FP64 subtrahend, out Matrix2x3FP64 difference)
         {
             difference.r1c1 = minuend.r1c1 - subtrahend.r1c1;
             difference.r1c2 = minuend.r1c2 - subtrahend.r1c2;
@@ -204,7 +204,7 @@ namespace BasicGeometry
             difference.r3c2 = minuend.r3c2 - subtrahend.r3c2;
         }
 
-        public static void Multiply(in FP64Matrix2x3 multiplicand, double multiplier, out FP64Matrix2x3 product)
+        public static void Multiply(in Matrix2x3FP64 multiplicand, double multiplier, out Matrix2x3FP64 product)
         {
             product.r1c1 = multiplicand.r1c1 * multiplier;
             product.r1c2 = multiplicand.r1c2 * multiplier;
@@ -216,19 +216,19 @@ namespace BasicGeometry
             product.r3c2 = multiplicand.r3c2 * multiplier;
         }
 
-        public static void Divide(in FP64Matrix2x3 dividend, double divisor, out FP64Matrix2x3 quotient)
+        public static void Divide(in Matrix2x3FP64 dividend, double divisor, out Matrix2x3FP64 quotient)
         {
             Multiply(dividend, 1.0 / divisor, out quotient);
         }
 
-        public static void GetRightProduct(in FP64Matrix2x3 matrix, in FP64Vector2 vector, out FP64Vector3 result)
+        public static void GetRightProduct(in Matrix2x3FP64 matrix, in Vector2FP64 vector, out Vector3FP64 result)
         {
             result.x1 = matrix.r1c1 * vector.x1 + matrix.r1c2 * vector.x2;
             result.x2 = matrix.r2c1 * vector.x1 + matrix.r2c2 * vector.x2;
             result.x3 = matrix.r3c1 * vector.x1 + matrix.r3c2 * vector.x2;
         }
 
-        public static void GetLeftProduct(in FP64Vector3 vector, in FP64Matrix2x3 matrix, out FP64Vector2 result)
+        public static void GetLeftProduct(in Vector3FP64 vector, in Matrix2x3FP64 matrix, out Vector2FP64 result)
         {
             result.x1 = vector.x1 * matrix.r1c1 + vector.x2 * matrix.r2c1 + vector.x3 * matrix.r3c1;
             result.x2 = vector.x1 * matrix.r1c2 + vector.x2 * matrix.r2c2 + vector.x3 * matrix.r3c2;

BasicGeometry/Matrix3x2FP32.cs

@@ -20,12 +20,12 @@
  */
 namespace BasicGeometry
 {
-    public struct FP32Matrix3x2
+    public struct Matrix3x2FP32
     {
         public float r1c1 = 0.0f, r1c2 = 0.0f, r1c3 = 0.0f;
         public float r2c1 = 0.0f, r2c2 = 0.0f, r2c3 = 0.0f;
 
-        public FP32Matrix3x2(in FP32Matrix3x2 matrix)
+        public Matrix3x2FP32(in Matrix3x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -36,7 +36,7 @@ namespace BasicGeometry
             this.r2c3 = matrix.r2c3;
         }
 
-        public FP32Matrix3x2(in FP64Matrix3x2 matrix)
+        public Matrix3x2FP32(in Matrix3x2FP64 matrix)
         {
             this.r1c1 = (float) matrix.r1c1;
             this.r1c2 = (float) matrix.r1c2;
@@ -47,7 +47,7 @@ namespace BasicGeometry
             this.r2c3 = (float) matrix.r2c3;
         }
 
-        public FP32Matrix3x2(in FP32Matrix2x3 matrix)
+        public Matrix3x2FP32(in Matrix2x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -58,7 +58,7 @@ namespace BasicGeometry
             this.r2c3 = matrix.r3c2;
         }
 
-        public FP32Matrix3x2(in FP64Matrix2x3 matrix)
+        public Matrix3x2FP32(in Matrix2x3FP64 matrix)
         {
             this.r1c1 = (float) matrix.r1c1;
             this.r1c2 = (float) matrix.r2c1;
@@ -80,7 +80,7 @@ namespace BasicGeometry
             this.r2c3 = 0.0f;
         }
     
-        public void SetValues(in FP32Matrix3x2 matrix)
+        public void SetValues(in Matrix3x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -91,7 +91,7 @@ namespace BasicGeometry
             this.r2c3 = matrix.r2c3;
         }
 
-        public void SetValues(in FP64Matrix3x2 matrix)
+        public void SetValues(in Matrix3x2FP64 matrix)
         {
             this.r1c1 = (float) matrix.r1c1;
             this.r1c2 = (float) matrix.r1c2;
@@ -102,7 +102,7 @@ namespace BasicGeometry
             this.r2c3 = (float) matrix.r2c3;
         }
     
-        public void SetTransposed(in FP32Matrix2x3 matrix)
+        public void SetTransposed(in Matrix2x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -113,7 +113,7 @@ namespace BasicGeometry
             this.r2c3 = matrix.r3c2;
         }
 
-        public void SetTransposed(in FP64Matrix2x3 matrix)
+        public void SetTransposed(in Matrix2x3FP64 matrix)
         {
             this.r1c1 = (float) matrix.r1c1;
             this.r1c2 = (float) matrix.r2c1;
@@ -156,7 +156,7 @@ namespace BasicGeometry
             this.r2c3 = r2;
         }
 
-        public void AppendScaled(in FP32Matrix3x2 matrix, float scale)
+        public void AppendScaled(in Matrix3x2FP32 matrix, float scale)
         {
             this.r1c1 += matrix.r1c1 * scale;
             this.r1c2 += matrix.r1c2 * scale;
@@ -167,7 +167,7 @@ namespace BasicGeometry
             this.r2c3 += matrix.r2c3 * scale;
         }
 
-        public static void Add(in FP32Matrix3x2 matrix1, in FP32Matrix3x2 matrix2, out FP32Matrix3x2 sum)
+        public static void Add(in Matrix3x2FP32 matrix1, in Matrix3x2FP32 matrix2, out Matrix3x2FP32 sum)
         {
             sum.r1c1 = matrix1.r1c1 + matrix2.r1c1;
             sum.r1c2 = matrix1.r1c2 + matrix2.r1c2;
@@ -178,7 +178,7 @@ namespace BasicGeometry
             sum.r2c3 = matrix1.r2c3 + matrix2.r2c3;
         }
 
-        public static void Subtract(in FP32Matrix3x2 minuend, in FP32Matrix3x2 subtrahend, out FP32Matrix3x2 difference)
+        public static void Subtract(in Matrix3x2FP32 minuend, in Matrix3x2FP32 subtrahend, out Matrix3x2FP32 difference)
         {
             difference.r1c1 = minuend.r1c1 - subtrahend.r1c1;
             difference.r1c2 = minuend.r1c2 - subtrahend.r1c2;
@@ -189,7 +189,7 @@ namespace BasicGeometry
             difference.r2c3 = minuend.r2c3 - subtrahend.r2c3;
         }
 
-        public static void Multiply(in FP32Matrix3x2 multiplicand, float multiplier, out FP32Matrix3x2 product)
+        public static void Multiply(in Matrix3x2FP32 multiplicand, float multiplier, out Matrix3x2FP32 product)
         {
             product.r1c1 = multiplicand.r1c1 * multiplier;
             product.r1c2 = multiplicand.r1c2 * multiplier;
@@ -200,18 +200,18 @@ namespace BasicGeometry
             product.r2c3 = multiplicand.r2c3 * multiplier;
         }
 
-        public static void Divide(in FP32Matrix3x2 dividend, float divisor, out FP32Matrix3x2 quotient)
+        public static void Divide(in Matrix3x2FP32 dividend, float divisor, out Matrix3x2FP32 quotient)
         {
             Multiply(dividend, 1.0f / divisor, out quotient);
         }
 
-        public static void GetRightProduct(in FP32Matrix3x2 matrix, in FP32Vector3 vector, out FP32Vector2 result)
+        public static void GetRightProduct(in Matrix3x2FP32 matrix, in Vector3FP32 vector, out Vector2FP32 result)
         {
             result.x1 = matrix.r1c1 * vector.x1 + matrix.r1c2 * vector.x2 + matrix.r1c3 * vector.x3;
             result.x2 = matrix.r2c1 * vector.x1 + matrix.r2c2 * vector.x2 + matrix.r2c3 * vector.x3;
         }
 
-        public static void GetLeftProduct(in FP32Vector2 vector, in FP32Matrix3x2 matrix, out FP32Vector3 result)
+        public static void GetLeftProduct(in Vector2FP32 vector, in Matrix3x2FP32 matrix, out Vector3FP32 result)
         {
             result.x1 = vector.x1 * matrix.r1c1 + vector.x2 * matrix.r2c1;
             result.x2 = vector.x1 * matrix.r1c2 + vector.x2 * matrix.r2c2;

BasicGeometry/Matrix3x2FP64.cs

@@ -22,12 +22,12 @@ using System;
  */
 namespace BasicGeometry
 {
-    public struct FP64Matrix3x2
+    public struct Matrix3x2FP64
     {
         public double r1c1 = 0.0, r1c2 = 0.0, r1c3 = 0.0;
         public double r2c1 = 0.0, r2c2 = 0.0, r2c3 = 0.0;
 
-        public FP64Matrix3x2(in FP64Matrix3x2 matrix)
+        public Matrix3x2FP64(in Matrix3x2FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -38,7 +38,7 @@ namespace BasicGeometry
             this.r2c3 = matrix.r2c3;
         }
 
-        public FP64Matrix3x2(in FP32Matrix3x2 matrix)
+        public Matrix3x2FP64(in Matrix3x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -49,7 +49,7 @@ namespace BasicGeometry
             this.r2c3 = matrix.r2c3;
         }
 
-        public FP64Matrix3x2(in FP64Matrix2x3 matrix)
+        public Matrix3x2FP64(in Matrix2x3FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -60,7 +60,7 @@ namespace BasicGeometry
             this.r2c3 = matrix.r2c2;
         }
 
-        public FP64Matrix3x2(in FP32Matrix2x3 matrix)
+        public Matrix3x2FP64(in Matrix2x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -83,7 +83,7 @@ namespace BasicGeometry
         }
     
 
-        public void SetValues(in FP64Matrix3x2 matrix)
+        public void SetValues(in Matrix3x2FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -94,7 +94,7 @@ namespace BasicGeometry
             this.r2c3 = matrix.r2c3;
         }
 
-        public void SetValues(in FP32Matrix3x2 matrix)
+        public void SetValues(in Matrix3x2FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -105,7 +105,7 @@ namespace BasicGeometry
             this.r2c3 = matrix.r2c3;
         }
 
-        public void SetTransposed(in FP64Matrix2x3 matrix)
+        public void SetTransposed(in Matrix2x3FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -116,7 +116,7 @@ namespace BasicGeometry
             this.r2c3 = matrix.r2c2;
         }
 
-        public void SetTransposed(in FP32Matrix2x3 matrix)
+        public void SetTransposed(in Matrix2x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r2c1;
@@ -159,7 +159,7 @@ namespace BasicGeometry
             this.r2c3 = r2;
         }
 
-        public void AppendScaled(in FP64Matrix3x2 matrix, double scale)
+        public void AppendScaled(in Matrix3x2FP64 matrix, double scale)
         {
             this.r1c1 += matrix.r1c1 * scale;
             this.r1c2 += matrix.r1c2 * scale;
@@ -170,7 +170,7 @@ namespace BasicGeometry
             this.r2c3 += matrix.r2c3 * scale;
         }
 
-        public static void Add(in FP64Matrix3x2 matrix1, in FP64Matrix3x2 matrix2, out FP64Matrix3x2 sum)
+        public static void Add(in Matrix3x2FP64 matrix1, in Matrix3x2FP64 matrix2, out Matrix3x2FP64 sum)
         {
             sum.r1c1 = matrix1.r1c1 + matrix2.r1c1;
             sum.r1c2 = matrix1.r1c2 + matrix2.r1c2;
@@ -181,7 +181,7 @@ namespace BasicGeometry
             sum.r2c3 = matrix1.r2c3 + matrix2.r2c3;
         }
 
-        public static void Subtract(in FP64Matrix3x2 minuend, in FP64Matrix3x2 subtrahend, out FP64Matrix3x2 difference)
+        public static void Subtract(in Matrix3x2FP64 minuend, in Matrix3x2FP64 subtrahend, out Matrix3x2FP64 difference)
         {
             difference.r1c1 = minuend.r1c1 - subtrahend.r1c1;
             difference.r1c2 = minuend.r1c2 - subtrahend.r1c2;
@@ -192,7 +192,7 @@ namespace BasicGeometry
             difference.r2c3 = minuend.r2c3 - subtrahend.r2c3;
         }
 
-        public static void Multiply(in FP64Matrix3x2 multiplicand, double multiplier, out FP64Matrix3x2 product)
+        public static void Multiply(in Matrix3x2FP64 multiplicand, double multiplier, out Matrix3x2FP64 product)
         {
             product.r1c1 = multiplicand.r1c1 * multiplier;
             product.r1c2 = multiplicand.r1c2 * multiplier;
@@ -203,18 +203,18 @@ namespace BasicGeometry
             product.r2c3 = multiplicand.r2c3 * multiplier;
         }
 
-        public static void Divide(in FP64Matrix3x2 dividend, double divisor, out FP64Matrix3x2 quotient)
+        public static void Divide(in Matrix3x2FP64 dividend, double divisor, out Matrix3x2FP64 quotient)
         {
             Multiply(dividend, 1.0 / divisor, out quotient);
         }
 
-        public static void GetRightProduct(in FP64Matrix3x2 matrix, in FP64Vector3 vector, out FP64Vector2 result)
+        public static void GetRightProduct(in Matrix3x2FP64 matrix, in Vector3FP64 vector, out Vector2FP64 result)
         {
             result.x1 = matrix.r1c1 * vector.x1 + matrix.r1c2 * vector.x2 + matrix.r1c3 * vector.x3;
             result.x2 = matrix.r2c1 * vector.x1 + matrix.r2c2 * vector.x2 + matrix.r2c3 * vector.x3;
         }
 
-        public static void GetLeftProduct(in FP64Vector2 vector, in FP64Matrix3x2 matrix, out FP64Vector3 result)
+        public static void GetLeftProduct(in Vector2FP64 vector, in Matrix3x2FP64 matrix, out Vector3FP64 result)
         {
             result.x1 = vector.x1 * matrix.r1c1 + vector.x2 * matrix.r2c1;
             result.x2 = vector.x1 * matrix.r1c2 + vector.x2 * matrix.r2c2;

BasicGeometry/Matrix3x3FP32.cs

@@ -23,20 +23,20 @@ using System;
 
 namespace BasicGeometry
 {
-    public struct FP32Matrix3x3
+    public struct Matrix3x3FP32
     {
         public float r1c1 = 0.0f, r1c2 = 0.0f, r1c3 = 0.0f;
         public float r2c1 = 0.0f, r2c2 = 0.0f, r2c3 = 0.0f;
         public float r3c1 = 0.0f, r3c2 = 0.0f, r3c3 = 0.0f;
 
-        public FP32Matrix3x3(float d1, float d2, float d3)
+        public Matrix3x3FP32(float d1, float d2, float d3)
         {
             this.r1c1 = d1;
             this.r2c2 = d2;
             this.r3c3 = d3;
         }
 
-        public FP32Matrix3x3(in FP32Matrix3x3 matrix)
+        public Matrix3x3FP32(in Matrix3x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -51,7 +51,7 @@ namespace BasicGeometry
             this.r3c3 = matrix.r3c3;
         }
 
-        public FP32Matrix3x3(in FP64Matrix3x3 matrix)
+        public Matrix3x3FP32(in Matrix3x3FP64 matrix)
         {
             this.r1c1 = (float)matrix.r1c1;
             this.r1c2 = (float)matrix.r1c2;
@@ -76,7 +76,7 @@ namespace BasicGeometry
         public readonly bool IsSingular()
         {
             float determinant = this.GetDeterminant();
-            return -FP32Utility.EPSYLON <= determinant && determinant <= FP32Utility.EPSYLON;
+            return -UtilityFP32.EPSYLON <= determinant && determinant <= UtilityFP32.EPSYLON;
         }
 
         public void Transpose()
@@ -90,7 +90,7 @@ namespace BasicGeometry
         {
             float determinant = this.GetDeterminant();
     
-            if (-FP32Utility.EPSYLON <= determinant && determinant <= FP32Utility.EPSYLON) {
+            if (-UtilityFP32.EPSYLON <= determinant && determinant <= UtilityFP32.EPSYLON) {
                 return false;
             }
 
@@ -168,7 +168,7 @@ namespace BasicGeometry
             this.r2c3 = d3;
         }
 
-        public void SetValues(in FP32Matrix3x3 matrix)
+        public void SetValues(in Matrix3x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -183,7 +183,7 @@ namespace BasicGeometry
             this.r3c3 = matrix.r3c3;
         }
 
-        public void SetValues(in FP64Matrix3x3 matrix)
+        public void SetValues(in Matrix3x3FP64 matrix)
         {
             this.r1c1 = (float)matrix.r1c1;
             this.r1c2 = (float)matrix.r1c2;
@@ -198,7 +198,7 @@ namespace BasicGeometry
             this.r3c3 = (float)matrix.r3c3;
         }
 
-        public void SetTransposedOf(in FP32Matrix3x3 matrix)
+        public void SetTransposedOf(in Matrix3x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r2c2 = matrix.r2c2;
@@ -209,7 +209,7 @@ namespace BasicGeometry
             (this.r2c3, this.r3c2) = (matrix.r3c2, matrix.r2c3);
         }
 
-        public void SetTransposedOf(in FP64Matrix3x3 matrix)
+        public void SetTransposedOf(in Matrix3x3FP64 matrix)
         {
             this.r1c1 = (float)matrix.r1c1;
             this.r1c2 = (float)matrix.r2c1;
@@ -224,11 +224,11 @@ namespace BasicGeometry
             this.r3c3 = (float)matrix.r3c3;
         }
 
-        public bool SetInvertedOf(in FP32Matrix3x3 matrix)
+        public bool SetInvertedOf(in Matrix3x3FP32 matrix)
         {
             float determinant = matrix.GetDeterminant();
     
-            if (-FP32Utility.EPSYLON <= determinant && determinant <= FP32Utility.EPSYLON) {
+            if (-UtilityFP32.EPSYLON <= determinant && determinant <= UtilityFP32.EPSYLON) {
                 return false;
             }
 
@@ -303,7 +303,7 @@ namespace BasicGeometry
             this.r3c3 = r3;
         }
 
-        public void AppendScaled(in FP32Matrix3x3 matrix, float scale)
+        public void AppendScaled(in Matrix3x3FP32 matrix, float scale)
         {
             this.r1c1 += matrix.r1c1* scale;
             this.r1c2 += matrix.r1c2* scale;
@@ -318,7 +318,7 @@ namespace BasicGeometry
             this.r3c3 += matrix.r3c3* scale;
         }
 
-        public static void Add(in FP32Matrix3x3 matrix1, in FP32Matrix3x3 matrix2, out FP32Matrix3x3 sum)
+        public static void Add(in Matrix3x3FP32 matrix1, in Matrix3x3FP32 matrix2, out Matrix3x3FP32 sum)
         {
             sum.r1c1 = matrix1.r1c1 + matrix2.r1c1;
             sum.r1c2 = matrix1.r1c2 + matrix2.r1c2;
@@ -333,7 +333,7 @@ namespace BasicGeometry
             sum.r3c3 = matrix1.r3c3 + matrix2.r3c3;
         }
 
-        public static void Subtract(in FP32Matrix3x3 minuend, in FP32Matrix3x3 subtrahend, out FP32Matrix3x3 difference)
+        public static void Subtract(in Matrix3x3FP32 minuend, in Matrix3x3FP32 subtrahend, out Matrix3x3FP32 difference)
         {
             difference.r1c1 = minuend.r1c1 - subtrahend.r1c1;
             difference.r1c2 = minuend.r1c2 - subtrahend.r1c2;
@@ -348,7 +348,7 @@ namespace BasicGeometry
             difference.r3c3 = minuend.r3c3 - subtrahend.r3c3;
         }
 
-        public static void Multiply(in FP32Matrix3x3 multiplicand, float multiplier, out FP32Matrix3x3 product)
+        public static void Multiply(in Matrix3x3FP32 multiplicand, float multiplier, out Matrix3x3FP32 product)
         {
             product.r1c1 = multiplicand.r1c1 * multiplier;
             product.r1c2 = multiplicand.r1c2 * multiplier;
@@ -363,12 +363,12 @@ namespace BasicGeometry
             product.r3c3 = multiplicand.r3c3 * multiplier;
         }
 
-        public static void Divide(in FP32Matrix3x3 dividend, float divisor, out FP32Matrix3x3 quotient)
+        public static void Divide(in Matrix3x3FP32 dividend, float divisor, out Matrix3x3FP32 quotient)
         {
             Multiply(dividend, 1.0f / divisor, out quotient);
         }
 
-        public static void GetRightProduct(in FP32Matrix3x3 matrix, in FP32Vector3 vector, out FP32Vector3 result)
+        public static void GetRightProduct(in Matrix3x3FP32 matrix, in Vector3FP32 vector, out Vector3FP32 result)
         {
             float x1 = matrix.r1c1 * vector.x1 + matrix.r1c2 * vector.x2 + matrix.r1c3 * vector.x3;
             float x2 = matrix.r2c1 * vector.x1 + matrix.r2c2 * vector.x2 + matrix.r2c3 * vector.x3;
@@ -379,7 +379,7 @@ namespace BasicGeometry
             result.x3 = x3;
         }
 
-        public static void GetLeftProduct(in FP32Vector3 vector, in FP32Matrix3x3 matrix, out FP32Vector3 result)
+        public static void GetLeftProduct(in Vector3FP32 vector, in Matrix3x3FP32 matrix, out Vector3FP32 result)
         {
             float x1 = vector.x1 * matrix.r1c1 + vector.x2 * matrix.r2c1 + vector.x3 * matrix.r3c1;
             float x2 = vector.x1 * matrix.r1c2 + vector.x2 * matrix.r2c2 + vector.x3 * matrix.r3c2;
@@ -390,7 +390,7 @@ namespace BasicGeometry
             result.x3 = x3;
         }
 
-        public static void LoadZero(out FP32Matrix3x3 matrix)
+        public static void LoadZero(out Matrix3x3FP32 matrix)
         {
             matrix.r1c1 = 0.0f;
             matrix.r1c2 = 0.0f;
@@ -405,7 +405,7 @@ namespace BasicGeometry
             matrix.r3c3 = 0.0f;
         }
 
-        public static void LoadIdentity(out FP32Matrix3x3 matrix)
+        public static void LoadIdentity(out Matrix3x3FP32 matrix)
         {
             matrix.r1c1 = 1.0f;
             matrix.r1c2 = 0.0f;
@@ -420,7 +420,7 @@ namespace BasicGeometry
             matrix.r3c3 = 1.0f;
         }
 
-        public static void LoadDiagonal(float d1, float d2, float d3, out FP32Matrix3x3 matrix)
+        public static void LoadDiagonal(float d1, float d2, float d3, out Matrix3x3FP32 matrix)
         {
             matrix.r1c1 = d1;
             matrix.r1c2 = 0.0f;

BasicGeometry/Matrix3x3FP64.cs

@@ -23,20 +23,20 @@ using System;
 
 namespace BasicGeometry
 {
-    public struct FP64Matrix3x3
+    public struct Matrix3x3FP64
     {
         public double r1c1 = 0.0, r1c2 = 0.0, r1c3 = 0.0;
         public double r2c1 = 0.0, r2c2 = 0.0, r2c3 = 0.0;
         public double r3c1 = 0.0, r3c2 = 0.0, r3c3 = 0.0;
 
-        public FP64Matrix3x3(double d1, double d2, double d3)
+        public Matrix3x3FP64(double d1, double d2, double d3)
         {
             this.r1c1 = d1;
             this.r2c2 = d2;
             this.r3c3 = d3;
         }
 
-        public FP64Matrix3x3(in FP64Matrix3x3 matrix)
+        public Matrix3x3FP64(in Matrix3x3FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -51,7 +51,7 @@ namespace BasicGeometry
             this.r3c3 = matrix.r3c3;
         }
 
-        public FP64Matrix3x3(in FP32Matrix3x3 matrix)
+        public Matrix3x3FP64(in Matrix3x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -76,7 +76,7 @@ namespace BasicGeometry
         public readonly bool IsSingular()
         {
             double determinant = this.GetDeterminant();
-            return -FP64Utility.EPSYLON <= determinant && determinant <= FP64Utility.EPSYLON;
+            return -UtilityFP64.EPSYLON <= determinant && determinant <= UtilityFP64.EPSYLON;
         }
 
         public void Transpose()
@@ -90,7 +90,7 @@ namespace BasicGeometry
         {
             double determinant = this.GetDeterminant();
     
-            if (-FP64Utility.EPSYLON <= determinant && determinant <= FP64Utility.EPSYLON) {
+            if (-UtilityFP64.EPSYLON <= determinant && determinant <= UtilityFP64.EPSYLON) {
                 return false;
             }
 
@@ -168,7 +168,7 @@ namespace BasicGeometry
             this.r2c3 = d3;
         }
 
-        public void SetValues(FP64Matrix3x3 matrix)
+        public void SetValues(Matrix3x3FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -183,7 +183,7 @@ namespace BasicGeometry
             this.r3c3 = matrix.r3c3;
         }
 
-        public void SetValues(FP32Matrix3x3 matrix)
+        public void SetValues(Matrix3x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r1c2 = matrix.r1c2;
@@ -198,7 +198,7 @@ namespace BasicGeometry
             this.r3c3 = matrix.r3c3;
         }
 
-        public void SetTransposedOf(in FP64Matrix3x3 matrix)
+        public void SetTransposedOf(in Matrix3x3FP64 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r2c2 = matrix.r2c2;
@@ -209,7 +209,7 @@ namespace BasicGeometry
             (this.r2c3, this.r3c2) = (matrix.r3c2, matrix.r2c3);
         }
 
-        public void SetTransposedOf(in FP32Matrix3x3 matrix)
+        public void SetTransposedOf(in Matrix3x3FP32 matrix)
         {
             this.r1c1 = matrix.r1c1;
             this.r2c2 = matrix.r2c2;
@@ -220,11 +220,11 @@ namespace BasicGeometry
             (this.r2c3, this.r3c2) = (matrix.r3c2, matrix.r2c3);
         }
 
-        public bool SetInvertedOf(in FP64Matrix3x3 matrix)
+        public bool SetInvertedOf(in Matrix3x3FP64 matrix)
         {
             double determinant = matrix.GetDeterminant();
     
-            if (-FP64Utility.EPSYLON <= determinant && determinant <= FP64Utility.EPSYLON) {
+            if (-UtilityFP64.EPSYLON <= determinant && determinant <= UtilityFP64.EPSYLON) {
                 return false;
             }
 
@@ -299,7 +299,7 @@ namespace BasicGeometry
             this.r3c3 = r3;
         }
 
-        public void AppendScaled(in FP64Matrix3x3 matrix, double scale)
+        public void AppendScaled(in Matrix3x3FP64 matrix, double scale)
         {
             this.r1c1 += matrix.r1c1 * scale;
             this.r1c2 += matrix.r1c2 * scale;
@@ -314,7 +314,7 @@ namespace BasicGeometry
             this.r3c3 += matrix.r3c3 * scale;
         }
 
-        public static void Add(in FP64Matrix3x3 matrix1, in FP64Matrix3x3 matrix2, out FP64Matrix3x3 sum)
+        public static void Add(in Matrix3x3FP64 matrix1, in Matrix3x3FP64 matrix2, out Matrix3x3FP64 sum)
         {
             sum.r1c1 = matrix1.r1c1 + matrix2.r1c1;
             sum.r1c2 = matrix1.r1c2 + matrix2.r1c2;
@@ -329,7 +329,7 @@ namespace BasicGeometry
             sum.r3c3 = matrix1.r3c3 + matrix2.r3c3;
         }
 
-        public static void Subtract(in FP64Matrix3x3 minuend, in FP64Matrix3x3 subtrahend, out FP64Matrix3x3 difference)
+        public static void Subtract(in Matrix3x3FP64 minuend, in Matrix3x3FP64 subtrahend, out Matrix3x3FP64 difference)
         {
             difference.r1c1 = minuend.r1c1 - subtrahend.r1c1;
             difference.r1c2 = minuend.r1c2 - subtrahend.r1c2;
@@ -344,7 +344,7 @@ namespace BasicGeometry
             difference.r3c3 = minuend.r3c3 - subtrahend.r3c3;
         }
 
-        public static void Multiply(in FP64Matrix3x3 multiplicand, double multiplier, out FP64Matrix3x3 product)
+        public static void Multiply(in Matrix3x3FP64 multiplicand, double multiplier, out Matrix3x3FP64 product)
         {
             product.r1c1 = multiplicand.r1c1 * multiplier;
             product.r1c2 = multiplicand.r1c2 * multiplier;
@@ -359,12 +359,12 @@ namespace BasicGeometry
             product.r3c3 = multiplicand.r3c3 * multiplier;
         }
 
-        public static void Divide(in FP64Matrix3x3 dividend, double divisor, out FP64Matrix3x3 quotient)
+        public static void Divide(in Matrix3x3FP64 dividend, double divisor, out Matrix3x3FP64 quotient)
         {
             Multiply(dividend, 1.0 / divisor, out quotient);
         }
 
-        public static void GetRightProduct(in FP64Matrix3x3 matrix, in FP64Vector3 vector, out FP64Vector3 result)
+        public static void GetRightProduct(in Matrix3x3FP64 matrix, in Vector3FP64 vector, out Vector3FP64 result)
         {
             double x1 = matrix.r1c1 * vector.x1 + matrix.r1c2 * vector.x2 + matrix.r1c3 * vector.x3;
             double x2 = matrix.r2c1 * vector.x1 + matrix.r2c2 * vector.x2 + matrix.r2c3 * vector.x3;
@@ -375,7 +375,7 @@ namespace BasicGeometry
             result.x3 = x3;
         }
 
-        public static void GetLeftProduct(in FP64Vector3 vector, in FP64Matrix3x3 matrix, out FP64Vector3 result)
+        public static void GetLeftProduct(in Vector3FP64 vector, in Matrix3x3FP64 matrix, out Vector3FP64 result)
         {
             double x1 = vector.x1 * matrix.r1c1 + vector.x2 * matrix.r2c1 + vector.x3 * matrix.r3c1;
             double x2 = vector.x1 * matrix.r1c2 + vector.x2 * matrix.r2c2 + vector.x3 * matrix.r3c2;
@@ -386,7 +386,7 @@ namespace BasicGeometry
             result.x3 = x3;
         }
 
-        public static void LoadZero(out FP64Matrix3x3 matrix)
+        public static void LoadZero(out Matrix3x3FP64 matrix)
         {
             matrix.r1c1 = 0.0;
             matrix.r1c2 = 0.0;
@@ -401,7 +401,7 @@ namespace BasicGeometry
             matrix.r3c3 = 0.0;
         }
 
-        public static void LoadIdentity(out FP64Matrix3x3 matrix)
+        public static void LoadIdentity(out Matrix3x3FP64 matrix)
         {
             matrix.r1c1 = 1.0;
             matrix.r1c2 = 0.0;
@@ -416,7 +416,7 @@ namespace BasicGeometry
             matrix.r3c3 = 1.0;
         }
 
-        public static void LoadDiagonal(double d1, double d2, double d3, out FP64Matrix3x3 matrix)
+        public static void LoadDiagonal(double d1, double d2, double d3, out Matrix3x3FP64 matrix)
         {
             matrix.r1c1 = d1;
             matrix.r1c2 = 0.0;

BasicGeometry/MatrixProductFP32.cs

@@ -22,9 +22,9 @@ using System;
  */
 namespace BasicGeometry
 {
-    public class FP32MatrixProduct
+    public class MatrixProductFP32
     {
-        public static void Get2x2At2x2(in FP32Matrix2x2 left, in FP32Matrix2x2 right, out FP32Matrix2x2 product)
+        public static void Get2x2At2x2(in Matrix2x2FP32 left, in Matrix2x2FP32 right, out Matrix2x2FP32 product)
         {
             float r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1;
             float r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2;
@@ -39,7 +39,7 @@ namespace BasicGeometry
             product.r2c2 = r2c2;
         }
 
-        public static void Get2x2At3x2(in FP32Matrix2x2 left, in FP32Matrix3x2 right, out FP32Matrix3x2 product)
+        public static void Get2x2At3x2(in Matrix2x2FP32 left, in Matrix3x2FP32 right, out Matrix3x2FP32 product)
         {
             float r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1;
             float r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2;
@@ -58,7 +58,7 @@ namespace BasicGeometry
             product.r2c3 = r2c3;
         }
     
-        public static void Get2x3At2x2(in FP32Matrix2x3 left, in FP32Matrix2x2 right, out FP32Matrix2x3 product)
+        public static void Get2x3At2x2(in Matrix2x3FP32 left, in Matrix2x2FP32 right, out Matrix2x3FP32 product)
         {
             float r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1;
             float r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2;
@@ -79,7 +79,7 @@ namespace BasicGeometry
             product.r3c2 = r3c2;
         }
 
-        public static void Get2x3At3x2(in FP32Matrix2x3 left, in FP32Matrix3x2 right, out FP32Matrix3x3 product)
+        public static void Get2x3At3x2(in Matrix2x3FP32 left, in Matrix3x2FP32 right, out Matrix3x3FP32 product)
         {
             product.r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1;
             product.r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2;
@@ -94,7 +94,7 @@ namespace BasicGeometry
             product.r3c3 = left.r3c1 * right.r1c2 + left.r3c2 * right.r2c3;
         }
 
-        public static void Get3x2At3x3(in FP32Matrix3x2 left, in FP32Matrix3x3 right, out FP32Matrix3x2 product)
+        public static void Get3x2At3x3(in Matrix3x2FP32 left, in Matrix3x3FP32 right, out Matrix3x2FP32 product)
         {
             float r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1 + left.r1c3 * right.r3c1;
             float r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2 + left.r1c3 * right.r3c2;
@@ -113,7 +113,7 @@ namespace BasicGeometry
             product.r2c3 = r2c3;
         }
 
-        public static void Get3x2At2x3(in FP32Matrix3x2 left, in FP32Matrix2x3 right, out FP32Matrix2x2 product)
+        public static void Get3x2At2x3(in Matrix3x2FP32 left, in Matrix2x3FP32 right, out Matrix2x2FP32 product)
         {
             product.r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1 + left.r1c3 * right.r3c1;
             product.r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2 + left.r1c3 * right.r3c2;
@@ -122,7 +122,7 @@ namespace BasicGeometry
             product.r2c2 = left.r2c1 * right.r1c2 + left.r2c2 * right.r2c2 + left.r2c3 * right.r3c2;
         }
 
-        public static void Get3x3At2x3(in FP32Matrix3x3 left, in FP32Matrix2x3 right, out FP32Matrix2x3 product)
+        public static void Get3x3At2x3(in Matrix3x3FP32 left, in Matrix2x3FP32 right, out Matrix2x3FP32 product)
         {
             float r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1 + left.r1c3 * right.r3c1;
             float r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2 + left.r1c3 * right.r3c2;
@@ -143,7 +143,7 @@ namespace BasicGeometry
             product.r3c2 = r3c2;
         }
 
-        public static void Get3x3At3x3(in FP32Matrix3x3 left, in FP32Matrix3x3 right, out FP32Matrix3x3 product)
+        public static void Get3x3At3x3(in Matrix3x3FP32 left, in Matrix3x3FP32 right, out Matrix3x3FP32 product)
         {
             float r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1 + left.r1c3 * right.r3c1;
             float r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2 + left.r1c3 * right.r3c2;

BasicGeometry/MatrixProductFP64.cs

@@ -22,9 +22,9 @@ using System;
  */
 namespace BasicGeometry
 {
-    public class FP64MatrixProduct
+    public class MatrixProductFP64
     {
-        public static void Get2x2At2x2(in FP64Matrix2x2 left, in FP64Matrix2x2 right, out FP64Matrix2x2 product)
+        public static void Get2x2At2x2(in Matrix2x2FP64 left, in Matrix2x2FP64 right, out Matrix2x2FP64 product)
         {
             double r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1;
             double r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2;
@@ -39,7 +39,7 @@ namespace BasicGeometry
             product.r2c2 = r2c2;
         }
 
-        public static void Get2x2At3x2(in FP64Matrix2x2 left, in FP64Matrix3x2 right, out FP64Matrix3x2 product)
+        public static void Get2x2At3x2(in Matrix2x2FP64 left, in Matrix3x2FP64 right, out Matrix3x2FP64 product)
         {
             double r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1;
             double r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2;
@@ -58,7 +58,7 @@ namespace BasicGeometry
             product.r2c3 = r2c3;
         }
     
-        public static void Get2x3At2x2(in FP64Matrix2x3 left, in FP64Matrix2x2 right, out FP64Matrix2x3 product)
+        public static void Get2x3At2x2(in Matrix2x3FP64 left, in Matrix2x2FP64 right, out Matrix2x3FP64 product)
         {
             double r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1;
             double r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2;
@@ -79,7 +79,7 @@ namespace BasicGeometry
             product.r3c2 = r3c2;
         }
 
-        public static void Get2x3At3x2(in FP64Matrix2x3 left, in FP64Matrix3x2 right, out FP64Matrix3x3 product)
+        public static void Get2x3At3x2(in Matrix2x3FP64 left, in Matrix3x2FP64 right, out Matrix3x3FP64 product)
         {
             product.r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1;
             product.r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2;
@@ -94,7 +94,7 @@ namespace BasicGeometry
             product.r3c3 = left.r3c1 * right.r1c2 + left.r3c2 * right.r2c3;
         }
 
-        public static void Get3x2At3x3(in FP64Matrix3x2 left, in FP64Matrix3x3 right, out FP64Matrix3x2 product)
+        public static void Get3x2At3x3(in Matrix3x2FP64 left, in Matrix3x3FP64 right, out Matrix3x2FP64 product)
         {
             double r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1 + left.r1c3 * right.r3c1;
             double r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2 + left.r1c3 * right.r3c2;
@@ -113,7 +113,7 @@ namespace BasicGeometry
             product.r2c3 = r2c3;
         }
 
-        public static void Get3x2At2x3(in FP64Matrix3x2 left, in FP64Matrix2x3 right, out FP64Matrix2x2 product)
+        public static void Get3x2At2x3(in Matrix3x2FP64 left, in Matrix2x3FP64 right, out Matrix2x2FP64 product)
         {
             product.r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1 + left.r1c3 * right.r3c1;
             product.r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2 + left.r1c3 * right.r3c2;
@@ -122,7 +122,7 @@ namespace BasicGeometry
             product.r2c2 = left.r2c1 * right.r1c2 + left.r2c2 * right.r2c2 + left.r2c3 * right.r3c2;
         }
 
-        public static void Get3x3At2x3(in FP64Matrix3x3 left, in FP64Matrix2x3 right, out FP64Matrix2x3 product)
+        public static void Get3x3At2x3(in Matrix3x3FP64 left, in Matrix2x3FP64 right, out Matrix2x3FP64 product)
         {
             double r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1 + left.r1c3 * right.r3c1;
             double r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2 + left.r1c3 * right.r3c2;
@@ -143,7 +143,7 @@ namespace BasicGeometry
             product.r3c2 = r3c2;
         }
 
-        public static void Get3x3At3x3(in FP64Matrix3x3 left, in FP64Matrix3x3 right, out FP64Matrix3x3 product)
+        public static void Get3x3At3x3(in Matrix3x3FP64 left, in Matrix3x3FP64 right, out Matrix3x3FP64 product)
         {
             double r1c1 = left.r1c1 * right.r1c1 + left.r1c2 * right.r2c1 + left.r1c3 * right.r3c1;
             double r1c2 = left.r1c1 * right.r1c2 + left.r1c2 * right.r2c2 + left.r1c3 * right.r3c2;

BasicGeometry/QuaternionFP32.cs

@@ -2,11 +2,11 @@
 
 namespace BasicGeometry
 {
-    public struct FP32Quaternion
+    public struct QuaternionFP32
     {
         public float s0 = 0.0f, x1 = 0.0f, x2 = 0.0f, x3 = 0.0f;
 
-        public FP32Quaternion(float s0, float x1, float x2, float x3)
+        public QuaternionFP32(float s0, float x1, float x2, float x3)
         {
             this.s0 = s0;
             this.x1 = x1;
@@ -14,7 +14,7 @@ namespace BasicGeometry
             this.x3 = x3;
         }
 
-        public FP32Quaternion(in FP32Quaternion quaternion)
+        public QuaternionFP32(in QuaternionFP32 quaternion)
         {
             this.s0 = quaternion.s0;
             this.x1 = quaternion.x1;
@@ -22,7 +22,7 @@ namespace BasicGeometry
             this.x3 = quaternion.x3;
         }
 
-        public FP32Quaternion(in FP64Quaternion quaternion)
+        public QuaternionFP32(in QuaternionFP64 quaternion)
         {
             this.s0 = (float)quaternion.s0;
             this.x1 = (float)quaternion.x1;
@@ -30,6 +30,26 @@ namespace BasicGeometry
             this.x3 = (float)quaternion.x3;
         }
 
+        public readonly float GetSquareModule()
+        {
+            return this.s0 * this.s0 + this.x1 * this.x1 + (this.x2 * this.x2 + this.x3 * this.x3);
+        }
+
+        public readonly float GetModule()
+        {
+            return MathF.Sqrt(this.GetSquareModule());
+        }
+
+        public readonly bool IsZero()
+        {
+            return this.GetSquareModule() <= UtilityFP32.SQUARE_EPSYLON;
+        }
+
+        public readonly bool IsUnit()
+        {
+            return UtilityFP32.IsSqareValueUnit(this.GetSquareModule());
+        }
+
         public void Reset()
         {
             this.s0 = 0.0f;
@@ -38,6 +58,14 @@ namespace BasicGeometry
             this.x3 = 0.0f;
         }
 
+        public void SetToIdentity()
+        {
+            this.s0 = 1.0f;
+            this.x1 = 0.0f;
+            this.x2 = 0.0f;
+            this.x3 = 0.0f;
+        }
+
         public void Conjugate()
         {
             this.x1 = -this.x1;
@@ -53,7 +81,7 @@ namespace BasicGeometry
             this.x3 = x3;
         }
 
-        public void SetValues(in FP32Quaternion quaternion)
+        public void SetValues(in QuaternionFP32 quaternion)
         {
             this.s0 = quaternion.s0;
             this.x1 = quaternion.x1;
@@ -61,7 +89,7 @@ namespace BasicGeometry
             this.x3 = quaternion.x3;
         }
 
-        public void SetValues(in FP64Quaternion quaternion)
+        public void SetValues(in QuaternionFP64 quaternion)
         {
             this.s0 = (float)quaternion.s0;
             this.x1 = (float)quaternion.x1;
@@ -69,7 +97,7 @@ namespace BasicGeometry
             this.x3 = (float)quaternion.x3;
         }
 
-        public void SetConjugateOf(in FP32Quaternion quaternion)
+        public void SetConjugateOf(in QuaternionFP32 quaternion)
         {
             this.s0 = quaternion.s0;
             this.x1 = -quaternion.x1;
@@ -77,7 +105,7 @@ namespace BasicGeometry
             this.x3 = -quaternion.x3;
         }
 
-        public readonly void MakeRotationMatrix(out FP32Matrix3x3 matrix)
+        public readonly void MakeRotationMatrix(out Matrix3x3FP32 matrix)
         {
             float s0s0 = this.s0 * this.s0;
             float x1x1 = this.x1 * this.x1;
@@ -86,23 +114,14 @@ namespace BasicGeometry
 
             float squareModule = (s0s0 + x1x1) + (x2x2 + x3x3);
 
-            if (-FP32Utility.EPSYLON <= squareModule && squareModule <= FP32Utility.EPSYLON)
+            if (squareModule <= UtilityFP32.SQUARE_EPSYLON)
             {
-                FP32Matrix3x3.LoadIdentity(out matrix);
+                Matrix3x3FP32.LoadIdentity(out matrix);
                 return;
             }
 
-            float corrector1;
+            float corrector1 = 1.0f / squareModule;
-            float corrector2;
+            float corrector2 = 2.0f * corrector1;
-
-            if (1.0f - FP32Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0f + FP32Utility.TWO_EPSYLON) {
-                corrector1 = 2.0f - squareModule;
-                corrector2 = 2.0f * corrector1;
-            }
-            else {
-                corrector1 = 1.0f / squareModule;
-                corrector2 = 2.0f / squareModule;
-            }
 
             float s0x1 = this.s0 * this.x1;
             float s0x2 = this.s0 * this.x2;
@@ -124,7 +143,7 @@ namespace BasicGeometry
             matrix.r1c3 = corrector2 * (x1x3 + s0x2);
         }
 
-        public readonly void MakeReverseMatrix(out FP32Matrix3x3 matrix)
+        public readonly void MakeReverseMatrix(out Matrix3x3FP32 matrix)
         {
             float s0s0 = this.s0 * this.s0;
             float x1x1 = this.x1 * this.x1;
@@ -133,23 +152,14 @@ namespace BasicGeometry
 
             float squareModule = (s0s0 + x1x1) + (x2x2 + x3x3);
 
-            if (-FP32Utility.EPSYLON <= squareModule && squareModule <= FP32Utility.EPSYLON)
+            if (squareModule <= UtilityFP32.SQUARE_EPSYLON)
             {
-                FP32Matrix3x3.LoadIdentity(out matrix);
+                Matrix3x3FP32.LoadIdentity(out matrix);
                 return;
             }
 
-            float corrector1;
+            float corrector1 = 1.0f / squareModule;
-            float corrector2;
+            float corrector2 = 2.0f * corrector1;
-
-            if (1.0f - FP32Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0f + FP32Utility.TWO_EPSYLON) {
-                corrector1 = 2.0f - squareModule;
-                corrector2 = 2.0f * corrector1;
-            }
-            else {
-                corrector1 = 1.0f / squareModule;
-                corrector2 = 2.0f / squareModule;
-            }
 
             float s0x1 = this.s0 * this.x1;
             float s0x2 = this.s0 * this.x2;
@@ -171,7 +181,7 @@ namespace BasicGeometry
             matrix.r1c3 = corrector2 * (x1x3 - s0x2);
         }
 
-        public static void Add(in FP32Quaternion quaternion1, in FP32Quaternion quaternion2, out FP32Quaternion sum)
+        public static void Add(in QuaternionFP32 quaternion1, in QuaternionFP32 quaternion2, out QuaternionFP32 sum)
         {
             sum.s0 = quaternion1.s0 + quaternion2.s0;
             sum.x1 = quaternion1.x1 + quaternion2.x1;
@@ -179,7 +189,7 @@ namespace BasicGeometry
             sum.x3 = quaternion1.x3 + quaternion2.x3;
         }
 
-        public static void Subtract(in FP32Quaternion minuend, in FP32Quaternion subtrahend, out FP32Quaternion difference)
+        public static void Subtract(in QuaternionFP32 minuend, in QuaternionFP32 subtrahend, out QuaternionFP32 difference)
         {
             difference.s0 = minuend.s0 - subtrahend.s0;
             difference.x1 = minuend.x1 - subtrahend.x1;
@@ -187,7 +197,7 @@ namespace BasicGeometry
             difference.x3 = minuend.x3 - subtrahend.x3;
         }
 
-        public static void Multiply(in FP32Quaternion left, in FP32Quaternion right, out FP32Quaternion product)
+        public static void Multiply(in QuaternionFP32 left, in QuaternionFP32 right, out QuaternionFP32 product)
         {
             float s0 = (left.s0 * right.s0 - left.x1 * right.x1) - (left.x2 * right.x2 + left.x3 * right.x3);
             float x1 = (left.x1 * right.s0 + left.s0 * right.x1) - (left.x3 * right.x2 - left.x2 * right.x3);

BasicGeometry/QuaternionFP64.cs

@@ -3,11 +3,11 @@ using System.Numerics;
 
 namespace BasicGeometry
 {
-    public struct FP64Quaternion
+    public struct QuaternionFP64
     {
         public double s0 = 0.0, x1 = 0.0, x2 = 0.0, x3 = 0.0;
 
-        public FP64Quaternion(double s0, double x1, double x2, double x3)
+        public QuaternionFP64(double s0, double x1, double x2, double x3)
         {
             this.s0 = s0;
             this.x1 = x1;
@@ -15,7 +15,7 @@ namespace BasicGeometry
             this.x3 = x3;
         }
 
-        public FP64Quaternion(in FP32Quaternion quaternion)
+        public QuaternionFP64(in QuaternionFP32 quaternion)
         {
             this.s0 = quaternion.s0;
             this.x1 = quaternion.x1;
@@ -23,7 +23,7 @@ namespace BasicGeometry
             this.x3 = quaternion.x3;
         }
 
-        public FP64Quaternion(in FP64Quaternion quaternion)
+        public QuaternionFP64(in QuaternionFP64 quaternion)
         {
             this.s0 = quaternion.s0;
             this.x1 = quaternion.x1;
@@ -31,6 +31,26 @@ namespace BasicGeometry
             this.x3 = quaternion.x3;
         }
 
+        public readonly double GetSquareModule()
+        {
+            return this.s0 * this.s0 + this.x1 * this.x1 + (this.x2 * this.x2 + this.x3 * this.x3);
+        }
+
+        public readonly double GetModule()
+        {
+            return Math.Sqrt(this.GetSquareModule());
+        }
+
+        public readonly bool IsZero()
+        {
+            return this.GetSquareModule() <= UtilityFP64.SQUARE_EPSYLON;
+        }
+
+        public readonly bool IsUnit()
+        {
+            return UtilityFP64.IsSqareValueUnit(this.GetSquareModule());
+        }
+
         public void Reset()
         {
             this.s0 = 0.0;
@@ -39,6 +59,14 @@ namespace BasicGeometry
             this.x3 = 0.0;
         }
 
+        public void SetToIdentity()
+        {
+            this.s0 = 1.0;
+            this.x1 = 0.0;
+            this.x2 = 0.0;
+            this.x3 = 0.0;
+        }
+
         public void Conjugate()
         {
             this.x1 = -this.x1;
@@ -54,7 +82,7 @@ namespace BasicGeometry
             this.x3 = x3;
         }
 
-        public void SetValues(in FP32Quaternion quaternion)
+        public void SetValues(in QuaternionFP32 quaternion)
         {
             this.s0 = quaternion.s0;
             this.x1 = quaternion.x1;
@@ -62,7 +90,7 @@ namespace BasicGeometry
             this.x3 = quaternion.x3;
         }
 
-        public void SetValues(in FP64Quaternion quaternion)
+        public void SetValues(in QuaternionFP64 quaternion)
         {
             this.s0 = quaternion.s0;
             this.x1 = quaternion.x1;
@@ -70,7 +98,7 @@ namespace BasicGeometry
             this.x3 = quaternion.x3;
         }
 
-        public void SetConjugateOf(in FP64Quaternion quaternion)
+        public void SetConjugateOf(in QuaternionFP64 quaternion)
         {
             this.s0 = quaternion.s0;
             this.x1 = -quaternion.x1;
@@ -78,7 +106,7 @@ namespace BasicGeometry
             this.x3 = -quaternion.x3;
         }
 
-        public readonly void MakeRotationMatrix(out FP64Matrix3x3 matrix)
+        public readonly void MakeRotationMatrix(out Matrix3x3FP64 matrix)
         {
             double s0s0 = this.s0 * this.s0;
             double x1x1 = this.x1 * this.x1;
@@ -87,23 +115,14 @@ namespace BasicGeometry
 
             double squareModule = (s0s0 + x1x1) + (x2x2 + x3x3);
 
-            if (-FP64Utility.EPSYLON <= squareModule && squareModule <= FP64Utility.EPSYLON)
+            if (squareModule <= UtilityFP64.SQUARE_EPSYLON)
             {
-                FP64Matrix3x3.LoadIdentity(out matrix);
+                Matrix3x3FP64.LoadIdentity(out matrix);
                 return;
             }
 
-            double corrector1;
+            double corrector1 = 1.0 / squareModule;
-            double corrector2;
+            double corrector2 = 2.0 * corrector1;
-
-            if (1.0 - FP64Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0 + FP64Utility.TWO_EPSYLON) {
-                corrector1 = 2.0 - squareModule;
-                corrector2 = 2.0 * corrector1;
-            }
-            else {
-                corrector1 = 1.0 / squareModule;
-                corrector2 = 2.0 / squareModule;
-            }
 
             double s0x1 = this.s0 * this.x1;
             double s0x2 = this.s0 * this.x2;
@@ -125,7 +144,7 @@ namespace BasicGeometry
             matrix.r1c3 = corrector2 * (x1x3 + s0x2);
         }
 
-        public readonly void MakeReverseMatrix(out FP64Matrix3x3 matrix)
+        public readonly void MakeReverseMatrix(out Matrix3x3FP64 matrix)
         {
             double s0s0 = this.s0 * this.s0;
             double x1x1 = this.x1 * this.x1;
@@ -134,23 +153,14 @@ namespace BasicGeometry
 
             double squareModule = (s0s0 + x1x1) + (x2x2 + x3x3);
 
-            if (-FP64Utility.EPSYLON <= squareModule && squareModule <= FP64Utility.EPSYLON)
+            if (squareModule <= UtilityFP64.SQUARE_EPSYLON)
             {
-                FP64Matrix3x3.LoadIdentity(out matrix);
+                Matrix3x3FP64.LoadIdentity(out matrix);
                 return;
             }
 
-            double corrector1;
+            double corrector1 = 1.0 / squareModule;
-            double corrector2;
+            double corrector2 = 2.0 * corrector1;
-
-            if (1.0 - FP64Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0 + FP64Utility.TWO_EPSYLON) {
-                corrector1 = 2.0 - squareModule;
-                corrector2 = 2.0 * corrector1;
-            }
-            else {
-                corrector1 = 1.0 / squareModule;
-                corrector2 = 2.0 / squareModule;
-            }
 
             double s0x1 = this.s0 * this.x1;
             double s0x2 = this.s0 * this.x2;
@@ -172,7 +182,7 @@ namespace BasicGeometry
             matrix.r1c3 = corrector2 * (x1x3 - s0x2);
         }
 
-        public static void Add(in FP64Quaternion quaternion1, in FP64Quaternion quaternion2, out FP64Quaternion sum)
+        public static void Add(in QuaternionFP64 quaternion1, in QuaternionFP64 quaternion2, out QuaternionFP64 sum)
         {
             sum.s0 = quaternion1.s0 + quaternion2.s0;
             sum.x1 = quaternion1.x1 + quaternion2.x1;
@@ -180,7 +190,7 @@ namespace BasicGeometry
             sum.x3 = quaternion1.x3 + quaternion2.x3;
         }
 
-        public static void Subtract(in FP64Quaternion minuend, in FP64Quaternion subtrahend, out FP64Quaternion difference)
+        public static void Subtract(in QuaternionFP64 minuend, in QuaternionFP64 subtrahend, out QuaternionFP64 difference)
         {
             difference.s0 = minuend.s0 - subtrahend.s0;
             difference.x1 = minuend.x1 - subtrahend.x1;
@@ -188,7 +198,7 @@ namespace BasicGeometry
             difference.x3 = minuend.x3 - subtrahend.x3;
         }
 
-        public static void Multiply(in FP64Quaternion left, in FP64Quaternion right, out FP64Quaternion product)
+        public static void Multiply(in QuaternionFP64 left, in QuaternionFP64 right, out QuaternionFP64 product)
         {
             double s0 = (left.s0 * right.s0 - left.x1 * right.x1) - (left.x2 * right.x2 + left.x3 * right.x3);
             double x1 = (left.x1 * right.s0 + left.s0 * right.x1) - (left.x3 * right.x2 - left.x2 * right.x3);

BasicGeometry/RadianFP32.cs

@@ -6,7 +6,7 @@
 
 namespace BasicGeometry
 {
-    public class FP32Radians
+    public class RadianFP32
     {
         public const float PI = 3.1415926536f;
         public const float TWO_PI = 6.2831853072f;

BasicGeometry/RadianFP64.cs

@@ -6,7 +6,7 @@
 
 namespace BasicGeometry
 {
-    public class FP64Radians
+    public class RadianFP64
     {
         public const double PI = 3.14159265358979324;
         public const double TWO_PI = 6.28318530717958648;

BasicGeometry/Rotation3FP32.cs

@@ -23,13 +23,13 @@ using System;
 
 namespace BasicGeometry
 {
-    public struct FP32Rotation3
+    public struct Rotation3FP32
     {
         private float angle = 0.0f;
 
-        private FP32Vector3 axis;
+        private Vector3FP32 axis;
 
-        public FP32Rotation3(FP32Rotation3 rotation)
+        public Rotation3FP32(Rotation3FP32 rotation)
         {
             this.angle = rotation.angle;
             this.axis = rotation.axis;

BasicGeometry/Rotation3FP64.cs

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2019-2025 Andrey Pokidov <andrey.pokidov@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+
+/*
+ * Author: Andrey Pokidov
+ * Date: 2 Feb 2019
+ */
+
+namespace BasicGeometry
+{
+    public struct Rotation3FP64
+    {
+        private double angle = 0.0;
+
+        private Vector3FP64 axis;
+
+        public Rotation3FP64(Rotation3FP64 rotation)
+        {
+            this.angle = rotation.angle;
+            this.axis = rotation.axis;
+        }
+
+        public void Reset()
+        {
+            this.angle = 0.0;
+            this.axis.Reset();
+        }
+    }
+}

BasicGeometry/TurnFP32.cs

@@ -6,11 +6,11 @@
 
 namespace BasicGeometry
 {
-    public class FP32Turns
+    public class TurnFP32
     {
         public static float ToRadians(float turns)
         {
-            return turns * FP32Radians.TWO_PI;
+            return turns * RadianFP32.TWO_PI;
         }
 
         public static float ToDegrees(float turns)
@@ -22,7 +22,7 @@ namespace BasicGeometry
         {
             if (toUnit == AngleUnit.RADIANS)
             {
-                return turns * FP32Radians.TWO_PI;
+                return turns * RadianFP32.TWO_PI;
             }
 
             if (toUnit == AngleUnit.DEGREES)

BasicGeometry/TurnFP64.cs

@@ -6,14 +6,14 @@
 
 namespace BasicGeometry
 {
-    public class FP64Turns
+    public class TurnFP64
     {
-        public static double TurnsToRadians(double turns)
+        public static double ToRadians(double turns)
         {
-            return turns * FP64Radians.TWO_PI;
+            return turns * RadianFP64.TWO_PI;
         }
 
-        public static double TurnsToDegrees(double turns)
+        public static double ToDegrees(double turns)
         {
             return turns * 360.0;
         }
@@ -22,7 +22,7 @@ namespace BasicGeometry
         {
             if (toUnit == AngleUnit.RADIANS)
             {
-                return turns * FP64Radians.TWO_PI;
+                return turns * RadianFP64.TWO_PI;
             }
 
             if (toUnit == AngleUnit.DEGREES)

BasicGeometry/UtilityFP32.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace BasicGeometry
+{
+    public class UtilityFP32
+    {
+        public const float EPSYLON = 4.76837E-7f;
+        public const float SQUARE_EPSYLON = 2.27373906E-13f;
+        
+        public const float EPSYLON_EFFECTIVENESS_LIMIT = 1.0f;
+
+        public const float ONE_THIRD = 0.333333333f;
+        public const float ONE_SIXTH = 0.166666667f;
+        public const float ONE_NINETH = 0.111111111f;
+
+        public const float GOLDEN_RATIO_HIGH = 1.618034f;
+        public const float GOLDEN_RATIO_LOW = 0.618034f;
+
+        public static bool IsZero(float value)
+        {
+            return -EPSYLON <= value && value <= EPSYLON;
+        }
+
+        public static bool IsUnit(float value)
+        {
+            return (1.0f - EPSYLON) <= value && value <= (1.0f + EPSYLON);
+        }
+
+        public static bool IsSqareValueUnit(float square)
+        {
+            return (1.0f - 2.0f * EPSYLON) <= square && square <= (1.0f + 2.0f * EPSYLON);
+        }
+
+        public static bool AreClose(float value1, float value2)
+        {
+            float difference = value1 - value2;
+            float squareValue1 = value1 * value1;
+            float squareValue2 = value2 * value2;
+            float squareDifference = difference * difference;
+
+            if (squareValue1 <= EPSYLON_EFFECTIVENESS_LIMIT || squareValue2 <= EPSYLON_EFFECTIVENESS_LIMIT) {
+                return squareDifference <= SQUARE_EPSYLON;
+            }
+
+            return squareDifference <= SQUARE_EPSYLON * squareValue1 && squareDifference <= SQUARE_EPSYLON * squareValue2;
+        }
+    }
+}

BasicGeometry/UtilityFP64.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace BasicGeometry
+{
+    public class UtilityFP64
+    {
+        public const double EPSYLON = 4.996003611E-14;
+        public const double SQUARE_EPSYLON = 2.496005208112504E-27;
+        
+        public const double EPSYLON_EFFECTIVENESS_LIMIT = 1.0;
+
+        public const double ONE_THIRD = 0.333333333333333333;
+        public const double ONE_SIXTH = 0.166666666666666667;
+        public const double ONE_NINETH = 0.111111111111111111;
+
+        public const double GOLDEN_RATIO_HIGH = 1.61803398874989485;
+        public const double GOLDEN_RATIO_LOW = 0.61803398874989485;
+
+        public static bool IsZero(double value)
+        {
+            return -EPSYLON <= value && value <= EPSYLON;
+        }
+
+        public static bool IsUnit(double value)
+        {
+            return (1.0 - EPSYLON) <= value && value <= (1.0 + EPSYLON);
+        }
+
+        public static bool IsSqareValueUnit(double square)
+        {
+            return (1.0 - 2.0 * EPSYLON) <= square && square <= (1.0 + 2.0 * EPSYLON);
+        }
+
+        public static bool AreClose(double value1, double value2)
+        {
+            double difference = value1 - value2;
+            double squareValue1 = value1 * value1;
+            double squareValue2 = value2 * value2;
+            double squareDifference = difference * difference;
+
+            if (squareValue1 <= EPSYLON_EFFECTIVENESS_LIMIT || squareValue2 <= EPSYLON_EFFECTIVENESS_LIMIT) {
+                return squareDifference <= SQUARE_EPSYLON;
+            }
+
+            return squareDifference <= SQUARE_EPSYLON * squareValue1 && squareDifference <= SQUARE_EPSYLON * squareValue2;
+        }
+    }
+}

BasicGeometry/Vector2FP32.cs

@@ -23,26 +23,26 @@ using System;
 
 namespace BasicGeometry
 {
-    public struct FP32Vector2
+    public struct Vector2FP32
     {
-        public static readonly FP32Vector2 ZERO = new FP32Vector2(0.0f, 0.0f);
+        public static readonly Vector2FP32 ZERO = new Vector2FP32(0.0f, 0.0f);
 
         public float x1 = 0.0f;
         public float x2 = 0.0f;
 
-        public FP32Vector2(float x1, float x2)
+        public Vector2FP32(float x1, float x2)
         {
             this.x1 = x1;
             this.x2 = x2;
         }
 
-        public FP32Vector2(in FP32Vector2 vector)
+        public Vector2FP32(in Vector2FP32 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
         }
 
-        public FP32Vector2(in FP64Vector2 vector)
+        public Vector2FP32(in Vector2FP64 vector)
         {
             this.x1 = (float)vector.x1;
             this.x2 = (float)vector.x2;
@@ -62,12 +62,12 @@ namespace BasicGeometry
         {
             float squareModule = this.GetSquareModule();
 
-            if (1.0f - FP32Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0f + FP32Utility.TWO_EPSYLON)
+            if (UtilityFP32.IsSqareValueUnit(squareModule))
             {
                 return 1;
             }
 
-            if (squareModule <= FP32Utility.SQUARE_EPSYLON)
+            if (squareModule <= UtilityFP32.SQUARE_EPSYLON)
             {
                 this.Reset();
                 return 0;
@@ -89,13 +89,12 @@ namespace BasicGeometry
 
         public readonly bool IsZero()
         {
-            return this.GetSquareModule() <= FP32Utility.SQUARE_EPSYLON;
+            return this.GetSquareModule() <= UtilityFP32.SQUARE_EPSYLON;
         }
 
         public readonly bool IsUnit()
         {
-            float squareModule = this.GetSquareModule();
+            return UtilityFP32.IsSqareValueUnit(this.GetSquareModule());
-            return 1.0f - FP32Utility.TWO_EPSYLON <= squareModule && squareModule <= FP32Utility.EPSYLON;
         }
 
         public void Reset()
@@ -110,31 +109,31 @@ namespace BasicGeometry
             this.x2 = x2;
         }
 
-        public void SetValues(in FP32Vector2 vector)
+        public void SetValues(in Vector2FP32 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
         }
 
-        public void SetValues(in FP64Vector2 vector)
+        public void SetValues(in Vector2FP64 vector)
         {
             this.x1 = (float)vector.x1;
             this.x2 = (float)vector.x2;
         }
 
-        public void SetReverseOf(in FP32Vector2 vector)
+        public void SetReverseOf(in Vector2FP32 vector)
         {
             this.x1 = -vector.x1;
             this.x2 = -vector.x2;
         }
 
-        public void SetReverseOf(in FP64Vector2 vector)
+        public void SetReverseOf(in Vector2FP64 vector)
         {
             this.x1 = -(float)vector.x1;
             this.x2 = -(float)vector.x2;
         }
 
-        public void AppendScaled(FP32Vector2 summand, float scale)
+        public void AppendScaled(Vector2FP32 summand, float scale)
         {
             this.x1 += summand.x1 * scale;
             this.x2 += summand.x2 * scale;
@@ -145,83 +144,83 @@ namespace BasicGeometry
             return String.Format("SPVector2({0}, {1})", this.x1, this.x2);
         }
 
-        public static void Add(in FP32Vector2 vector1, in FP32Vector2 vector2, out FP32Vector2 sum)
+        public static void Add(in Vector2FP32 vector1, in Vector2FP32 vector2, out Vector2FP32 sum)
         {
             sum.x1 = vector1.x1 + vector2.x1;
             sum.x2 = vector1.x2 + vector2.x2;
         }
 
-        public static void Subtract(in FP32Vector2 minuend, in FP32Vector2 subtrahend, out FP32Vector2 difference)
+        public static void Subtract(in Vector2FP32 minuend, in Vector2FP32 subtrahend, out Vector2FP32 difference)
         {
             difference.x1 = minuend.x1 - subtrahend.x1;
             difference.x2 = minuend.x2 - subtrahend.x2;
         }
 
-        public static void Multiply(in FP32Vector2 multiplicand, float multiplier, out FP32Vector2 product)
+        public static void Multiply(in Vector2FP32 multiplicand, float multiplier, out Vector2FP32 product)
         {
             product.x1 = multiplicand.x1 * multiplier;
             product.x2 = multiplicand.x2 * multiplier;
         }
 
-        public static void Divide(in FP32Vector2 dividend, float divisor, out FP32Vector2 quotient)
+        public static void Divide(in Vector2FP32 dividend, float divisor, out Vector2FP32 quotient)
         {
             Multiply(dividend, 1.0f / divisor, out quotient);
         }
 
-        public static void GetMean2(in FP32Vector2 vector1, in FP32Vector2 vector2, out FP32Vector2 result)
+        public static void GetMean2(in Vector2FP32 vector1, in Vector2FP32 vector2, out Vector2FP32 result)
         {
             result.x1 = (vector1.x1 + vector2.x1) * 0.5f;
             result.x2 = (vector1.x2 + vector2.x2) * 0.5f;
         }
 
-        public static void GetMean3(in FP32Vector2 vector1, in FP32Vector2 vector2, in FP32Vector2 vector3, out FP32Vector2 result)
+        public static void GetMean3(in Vector2FP32 vector1, in Vector2FP32 vector2, in Vector2FP32 vector3, out Vector2FP32 result)
         {
-            result.x1 = (vector1.x1 + vector2.x1 + vector3.x1) * FP32Utility.ONE_THIRD;
+            result.x1 = (vector1.x1 + vector2.x1 + vector3.x1) * UtilityFP32.ONE_THIRD;
-            result.x2 = (vector1.x2 + vector2.x2 + vector3.x2) * FP32Utility.ONE_THIRD;
+            result.x2 = (vector1.x2 + vector2.x2 + vector3.x2) * UtilityFP32.ONE_THIRD;
         }
 
-        public static float GetScalarProduct(in FP32Vector2 vector1, in FP32Vector2 vector2)
+        public static float GetScalarProduct(in Vector2FP32 vector1, in Vector2FP32 vector2)
         {
             return vector1.x1 * vector2.x1 + vector1.x2 * vector2.x2;
         }
  
-        public static float GetCrossProduct(in FP32Vector2 vector1, in FP32Vector2 vector2)
+        public static float GetCrossProduct(in Vector2FP32 vector1, in Vector2FP32 vector2)
         {
             return vector1.x1 * vector2.x2 - vector1.x2 * vector2.x1;
         }
 
-        public static float GetAngle(in FP32Vector2 vector1, in FP32Vector2 vector2, AngleUnit unit)
+        public static float GetAngle(in Vector2FP32 vector1, in Vector2FP32 vector2, AngleUnit unit)
         {
             float squareModule1 = vector1.GetSquareModule();
 
-            if (squareModule1 <= FP32Utility.SQUARE_EPSYLON)
+            if (squareModule1 <= UtilityFP32.SQUARE_EPSYLON)
             {
                 return 0.0f;
             }
 
             float squareModule2 = vector2.GetSquareModule();
 
-            if (squareModule2 <= FP32Utility.SQUARE_EPSYLON)
+            if (squareModule2 <= UtilityFP32.SQUARE_EPSYLON)
             {
                 return 0.0f;
             }
 
-            float cosine = FP32Vector2.GetScalarProduct(vector1, vector2) / MathF.Sqrt(squareModule1 * squareModule2);
+            float cosine = Vector2FP32.GetScalarProduct(vector1, vector2) / MathF.Sqrt(squareModule1 * squareModule2);
 
-            if (1.0f - FP32Utility.EPSYLON <= cosine)
+            if (1.0f - UtilityFP32.EPSYLON <= cosine)
             {
                 return 0.0f;
             }
 
-            if (cosine <= -(1.0f - FP32Utility.EPSYLON))
+            if (cosine <= -(1.0f - UtilityFP32.EPSYLON))
             {
-                return FP32Angle.GetHalfCircle(unit);
+                return AngleFP32.GetHalfCircle(unit);
             }
     
-            return FP32Radians.ToUnits(MathF.Acos(cosine), unit);
+            return RadianFP32.ToUnits(MathF.Acos(cosine), unit);
         }
     
-        public static float GetSquareDistance(in FP32Vector2 vector1, in FP32Vector2 vector2)
+        public static float GetSquareDistance(in Vector2FP32 vector1, in Vector2FP32 vector2)
         {
             float dx1 = vector1.x1 - vector2.x1;
             float dx2 = vector1.x2 - vector2.x2;
@@ -229,29 +228,29 @@ namespace BasicGeometry
             return dx1 * dx1 + dx2 * dx2;
         }
     
-        public static float GetDistance(in FP32Vector2 vector1, in FP32Vector2 vector2)
+        public static float GetDistance(in Vector2FP32 vector1, in Vector2FP32 vector2)
         {
             return MathF.Sqrt(GetSquareDistance(vector1, vector2));
         }
     
-        public static bool AreEqual(in FP32Vector2 vector1, in FP32Vector2 vector2)
+        public static bool AreEqual(in Vector2FP32 vector1, in Vector2FP32 vector2)
         {
             float squareModule1 = vector1.GetSquareModule();
             float squareModule2 = vector2.GetSquareModule();
             float squareModule3 = GetSquareDistance(vector1, vector2);
 
             // 2.0f means dimension amount
-            if (squareModule1 < FP32Utility.EPSYLON_EFFECTIVENESS_LIMIT || squareModule2 < FP32Utility.EPSYLON_EFFECTIVENESS_LIMIT)
+            if (squareModule1 < UtilityFP32.EPSYLON_EFFECTIVENESS_LIMIT || squareModule2 < UtilityFP32.EPSYLON_EFFECTIVENESS_LIMIT)
             {
-                return squareModule3 < (2.0f * FP32Utility.SQUARE_EPSYLON);
+                return squareModule3 < (2.0f * UtilityFP32.SQUARE_EPSYLON);
             }
 
             if (squareModule1 <= squareModule2)
             {
-                return squareModule3 <= (2.0f * FP32Utility.SQUARE_EPSYLON) * squareModule2;
+                return squareModule3 <= (2.0f * UtilityFP32.SQUARE_EPSYLON) * squareModule2;
             }
 
-            return squareModule3 <= (2.0f * FP32Utility.SQUARE_EPSYLON) * squareModule1;
+            return squareModule3 <= (2.0f * UtilityFP32.SQUARE_EPSYLON) * squareModule1;
         }
     }
 }

BasicGeometry/Vector2FP64.cs

@@ -23,26 +23,26 @@ using System;
 
 namespace BasicGeometry
 {
-    public struct FP64Vector2
+    public struct Vector2FP64
     {
-        public static readonly FP64Vector2 ZERO = new FP64Vector2(0.0, 0.0);
+        public static readonly Vector2FP64 ZERO = new Vector2FP64(0.0, 0.0);
 
         public double x1 = 0.0;
         public double x2 = 0.0;
 
-        public FP64Vector2(double x1, double x2)
+        public Vector2FP64(double x1, double x2)
         {
             this.x1 = x1;
             this.x2 = x2;
         }
 
-        public FP64Vector2(in FP64Vector2 vector)
+        public Vector2FP64(in Vector2FP64 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
         }
 
-        public FP64Vector2(in FP32Vector2 vector)
+        public Vector2FP64(in Vector2FP32 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
@@ -62,12 +62,12 @@ namespace BasicGeometry
         {
             double squareModule = this.GetSquareModule();
 
-            if (1.0 - FP64Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0 + FP64Utility.TWO_EPSYLON)
+            if (UtilityFP64.IsSqareValueUnit(squareModule))
             {
                 return 1;
             }
 
-            if (squareModule <= FP64Utility.SQUARE_EPSYLON)
+            if (squareModule <= UtilityFP64.SQUARE_EPSYLON)
             {
                 this.Reset();
                 return 0;
@@ -89,13 +89,12 @@ namespace BasicGeometry
 
         public readonly bool IsZero()
         {
-            return this.GetSquareModule() <= FP64Utility.SQUARE_EPSYLON;
+            return this.GetSquareModule() <= UtilityFP64.SQUARE_EPSYLON;
         }
 
         public readonly bool IsUnit()
         {
-            double squareModule = this.GetSquareModule();
+            return UtilityFP64.IsSqareValueUnit(this.GetSquareModule());
-            return 1.0 - FP64Utility.TWO_EPSYLON <= squareModule && squareModule <= FP64Utility.EPSYLON;
         }
 
         public void Reset()
@@ -110,31 +109,31 @@ namespace BasicGeometry
             this.x2 = x2;
         }
 
-        public void SetValues(in FP64Vector2 vector)
+        public void SetValues(in Vector2FP64 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
         }
 
-        public void SetValues(in FP32Vector2 vector)
+        public void SetValues(in Vector2FP32 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
         }
 
-        public void SetReverseOf(in FP64Vector2 vector)
+        public void SetReverseOf(in Vector2FP64 vector)
         {
             this.x1 = -vector.x1;
             this.x2 = -vector.x2;
         }
 
-        public void SetReverseOf(in FP32Vector2 vector)
+        public void SetReverseOf(in Vector2FP32 vector)
         {
             this.x1 = -vector.x1;
             this.x2 = -vector.x2;
         }
 
-        public void AppendScaled(FP64Vector2 summand, double scale)
+        public void AppendScaled(Vector2FP64 summand, double scale)
         {
             this.x1 += summand.x1 * scale;
             this.x2 += summand.x2 * scale;
@@ -145,83 +144,83 @@ namespace BasicGeometry
             return String.Format("DPVector2({0}, {1})", this.x1, this.x2);
         }
 
-        public static void Add(in FP64Vector2 vector1, in FP64Vector2 vector2, out FP64Vector2 sum)
+        public static void Add(in Vector2FP64 vector1, in Vector2FP64 vector2, out Vector2FP64 sum)
         {
             sum.x1 = vector1.x1 + vector2.x1;
             sum.x2 = vector1.x2 + vector2.x2;
         }
 
-        public static void Subtract(in FP64Vector2 minuend, in FP64Vector2 subtrahend, out FP64Vector2 difference)
+        public static void Subtract(in Vector2FP64 minuend, in Vector2FP64 subtrahend, out Vector2FP64 difference)
         {
             difference.x1 = minuend.x1 - subtrahend.x1;
             difference.x2 = minuend.x2 - subtrahend.x2;
         }
 
-        public static void Multiply(in FP64Vector2 multiplicand, double multiplier, out FP64Vector2 product)
+        public static void Multiply(in Vector2FP64 multiplicand, double multiplier, out Vector2FP64 product)
         {
             product.x1 = multiplicand.x1 * multiplier;
             product.x2 = multiplicand.x2 * multiplier;
         }
 
-        public static void Divide(in FP64Vector2 dividend, double divisor, out FP64Vector2 quotient)
+        public static void Divide(in Vector2FP64 dividend, double divisor, out Vector2FP64 quotient)
         {
             Multiply(dividend, 1.0 / divisor, out quotient);
         }
 
-        public static void GetMean2(in FP64Vector2 vector1, in FP64Vector2 vector2, out FP64Vector2 result)
+        public static void GetMean2(in Vector2FP64 vector1, in Vector2FP64 vector2, out Vector2FP64 result)
         {
             result.x1 = (vector1.x1 + vector2.x1) * 0.5;
             result.x2 = (vector1.x2 + vector2.x2) * 0.5;
         }
 
-        public static void GetMean3(in FP64Vector2 vector1, in FP64Vector2 vector2, in FP64Vector2 vector3, out FP64Vector2 result)
+        public static void GetMean3(in Vector2FP64 vector1, in Vector2FP64 vector2, in Vector2FP64 vector3, out Vector2FP64 result)
         {
-            result.x1 = (vector1.x1 + vector2.x1 + vector3.x1) * FP64Utility.ONE_THIRD;
+            result.x1 = (vector1.x1 + vector2.x1 + vector3.x1) * UtilityFP64.ONE_THIRD;
-            result.x2 = (vector1.x2 + vector2.x2 + vector3.x2) * FP64Utility.ONE_THIRD;
+            result.x2 = (vector1.x2 + vector2.x2 + vector3.x2) * UtilityFP64.ONE_THIRD;
         }
 
-        public static double GetScalarProduct(in FP64Vector2 vector1, in FP64Vector2 vector2)
+        public static double GetScalarProduct(in Vector2FP64 vector1, in Vector2FP64 vector2)
         {
             return vector1.x1 * vector2.x1 + vector1.x2 * vector2.x2;
         }
  
-        public static double GetCrossProduct(in FP64Vector2 vector1, in FP64Vector2 vector2)
+        public static double GetCrossProduct(in Vector2FP64 vector1, in Vector2FP64 vector2)
         {
             return vector1.x1 * vector2.x2 - vector1.x2 * vector2.x1;
         }
 
-        public static double GetAngle(in FP64Vector2 vector1, in FP64Vector2 vector2, AngleUnit unit)
+        public static double GetAngle(in Vector2FP64 vector1, in Vector2FP64 vector2, AngleUnit unit)
         {
             double squareModule1 = vector1.GetSquareModule();
 
-            if (squareModule1 <= FP64Utility.SQUARE_EPSYLON)
+            if (squareModule1 <= UtilityFP64.SQUARE_EPSYLON)
             {
                 return 0.0;
             }
 
             double squareModule2 = vector2.GetSquareModule();
 
-            if (squareModule2 <= FP64Utility.SQUARE_EPSYLON)
+            if (squareModule2 <= UtilityFP64.SQUARE_EPSYLON)
             {
                 return 0.0;
             }
 
-            double cosine = FP64Vector2.GetScalarProduct(vector1, vector2) / Math.Sqrt(squareModule1 * squareModule2);
+            double cosine = Vector2FP64.GetScalarProduct(vector1, vector2) / Math.Sqrt(squareModule1 * squareModule2);
 
-            if (1.0 - FP64Utility.EPSYLON <= cosine)
+            if (1.0 - UtilityFP64.EPSYLON <= cosine)
             {
                 return 0.0;
             }
 
-            if (cosine <= -(1.0 - FP64Utility.EPSYLON))
+            if (cosine <= -(1.0 - UtilityFP64.EPSYLON))
             {
-                return FP64Angle.GetHalfCircle(unit);
+                return AngleFP64.GetHalfCircle(unit);
             }
     
-            return FP64Radians.ToUnits(Math.Acos(cosine), unit);
+            return RadianFP64.ToUnits(Math.Acos(cosine), unit);
         }
 
-        public static double GetSquareDistance(in FP64Vector2 vector1, in FP64Vector2 vector2)
+        public static double GetSquareDistance(in Vector2FP64 vector1, in Vector2FP64 vector2)
         {
             double dx1 = vector1.x1 - vector2.x1;
             double dx2 = vector1.x2 - vector2.x2;
@@ -229,29 +228,29 @@ namespace BasicGeometry
             return dx1 * dx1 + dx2 * dx2;
         }
     
-        public static double GetDistance(in FP64Vector2 vector1, in FP64Vector2 vector2)
+        public static double GetDistance(in Vector2FP64 vector1, in Vector2FP64 vector2)
         {
             return Math.Sqrt(GetSquareDistance(vector1, vector2));
         }
     
-        public static bool AreEqual(in FP64Vector2 vector1, in FP64Vector2 vector2)
+        public static bool AreEqual(in Vector2FP64 vector1, in Vector2FP64 vector2)
         {
             double squareModule1 = vector1.GetSquareModule();
             double squareModule2 = vector2.GetSquareModule();
             double squareModule3 = GetSquareDistance(vector1, vector2);
 
             // 2.0 means dimension amount
-            if (squareModule1 < FP64Utility.EPSYLON_EFFECTIVENESS_LIMIT || squareModule2 < FP64Utility.EPSYLON_EFFECTIVENESS_LIMIT)
+            if (squareModule1 < UtilityFP64.EPSYLON_EFFECTIVENESS_LIMIT || squareModule2 < UtilityFP64.EPSYLON_EFFECTIVENESS_LIMIT)
             {
-                return squareModule3 < (2.0 * FP64Utility.SQUARE_EPSYLON);
+                return squareModule3 < (2.0 * UtilityFP64.SQUARE_EPSYLON);
             }
 
             if (squareModule1 <= squareModule2)
             {
-                return squareModule3 <= (2.0 * FP64Utility.SQUARE_EPSYLON) * squareModule2;
+                return squareModule3 <= (2.0 * UtilityFP64.SQUARE_EPSYLON) * squareModule2;
             }
 
-            return squareModule3 <= (2.0 * FP64Utility.SQUARE_EPSYLON) * squareModule1;
+            return squareModule3 <= (2.0 * UtilityFP64.SQUARE_EPSYLON) * squareModule1;
         }
     }
 }

BasicGeometry/Vector3FP32.cs

@@ -23,29 +23,29 @@ using System;
 
 namespace BasicGeometry
 {
-    public struct FP32Vector3
+    public struct Vector3FP32
     {
-        public static readonly FP32Vector3 ZERO = new FP32Vector3(0.0f, 0.0f, 0.0f);
+        public static readonly Vector3FP32 ZERO = new Vector3FP32(0.0f, 0.0f, 0.0f);
 
         public float x1 = 0.0f;
         public float x2 = 0.0f;
         public float x3 = 0.0f;
 
-        public FP32Vector3(float x1, float x2, float x3)
+        public Vector3FP32(float x1, float x2, float x3)
         {
             this.x1 = x1;
             this.x2 = x2;
             this.x3 = x3;
         }
 
-        public FP32Vector3(in FP32Vector3 vector)
+        public Vector3FP32(in Vector3FP32 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
             this.x3 = vector.x3;
         }
 
-        public FP32Vector3(in FP64Vector3 vector)
+        public Vector3FP32(in Vector3FP64 vector)
         {
             this.x1 = (float)vector.x1;
             this.x2 = (float)vector.x2;
@@ -66,12 +66,12 @@ namespace BasicGeometry
         {
             float squareModule = this.GetSquareModule();
 
-            if (1.0f - FP32Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0f + FP32Utility.TWO_EPSYLON)
+            if (UtilityFP32.IsSqareValueUnit(squareModule))
             {
                 return 1;
             }
 
-            if (squareModule <= FP32Utility.SQUARE_EPSYLON)
+            if (squareModule <= UtilityFP32.SQUARE_EPSYLON)
             {
                 this.Reset();
                 return 0;
@@ -95,13 +95,12 @@ namespace BasicGeometry
 
         public readonly bool IsZero()
         {
-            return this.GetSquareModule() <= FP32Utility.SQUARE_EPSYLON;
+            return this.GetSquareModule() <= UtilityFP32.SQUARE_EPSYLON;
         }
 
         public readonly bool IsUnit()
         {
-            float squareModule = this.GetSquareModule();
+            return UtilityFP32.IsSqareValueUnit(this.GetSquareModule());
-            return 1.0f - FP32Utility.TWO_EPSYLON <= squareModule && squareModule <= FP32Utility.EPSYLON;
         }
 
         public void Reset()
@@ -118,35 +117,35 @@ namespace BasicGeometry
             this.x3 = x3;
         }
 
-        public void SetValues(in FP64Vector3 vector)
+        public void SetValues(in Vector3FP64 vector)
         {
             this.x1 = (float)vector.x1;
             this.x2 = (float)vector.x2;
             this.x3 = (float)vector.x3;
         }
 
-        public void SetValues(in FP32Vector3 vector)
+        public void SetValues(in Vector3FP32 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
             this.x3 = vector.x3;
         }
 
-        public void SetReverseOf(in FP32Vector3 vector)
+        public void SetReverseOf(in Vector3FP32 vector)
         {
             this.x1 = -vector.x1;
             this.x2 = -vector.x2;
             this.x3 = -vector.x3;
         }
 
-        public void SetReverseOf(in FP64Vector3 vector)
+        public void SetReverseOf(in Vector3FP64 vector)
         {
             this.x1 = -(float)vector.x1;
             this.x2 = -(float)vector.x2;
             this.x3 = -(float)vector.x3;
         }
 
-        public void AppendScaled(FP32Vector3 summand, float scale)
+        public void AppendScaled(Vector3FP32 summand, float scale)
         {
             this.x1 += summand.x1 * scale;
             this.x2 += summand.x2 * scale;
@@ -158,52 +157,52 @@ namespace BasicGeometry
             return String.Format("SPVector3({0}, {1}, {2})", this.x1, this.x2, this.x3);
         }
 
-        public static void Add(in FP32Vector3 vector1, in FP32Vector3 vector2, out FP32Vector3 sum)
+        public static void Add(in Vector3FP32 vector1, in Vector3FP32 vector2, out Vector3FP32 sum)
         {
             sum.x1 = vector1.x1 + vector2.x1;
             sum.x2 = vector1.x2 + vector2.x2;
             sum.x3 = vector1.x3 + vector2.x3;
         }
 
-        public static void Subtract(in FP32Vector3 minuend, in FP32Vector3 subtrahend, out FP32Vector3 difference)
+        public static void Subtract(in Vector3FP32 minuend, in Vector3FP32 subtrahend, out Vector3FP32 difference)
         {
             difference.x1 = minuend.x1 - subtrahend.x1;
             difference.x2 = minuend.x2 - subtrahend.x2;
             difference.x3 = minuend.x3 - subtrahend.x3;
         }
 
-        public static void Multiply(in FP32Vector3 multiplicand, float multiplier, out FP32Vector3 product)
+        public static void Multiply(in Vector3FP32 multiplicand, float multiplier, out Vector3FP32 product)
         {
             product.x1 = multiplicand.x1 * multiplier;
             product.x2 = multiplicand.x2 * multiplier;
             product.x3 = multiplicand.x3 * multiplier;
         }
 
-        public static void Divide(in FP32Vector3 dividend, float divisor, out FP32Vector3 quotient)
+        public static void Divide(in Vector3FP32 dividend, float divisor, out Vector3FP32 quotient)
         {
             Multiply(dividend, 1.0f / divisor, out quotient);
         }
 
-        public static void GetMean2(in FP32Vector3 vector1, in FP32Vector3 vector2, out FP32Vector3 result)
+        public static void GetMean2(in Vector3FP32 vector1, in Vector3FP32 vector2, out Vector3FP32 result)
         {
             result.x1 = (vector1.x1 + vector2.x1) * 0.5f;
             result.x2 = (vector1.x2 + vector2.x2) * 0.5f;
             result.x3 = (vector1.x3 + vector2.x3) * 0.5f;
         }
 
-        public static void GetMean3(in FP32Vector3 vector1, in FP32Vector3 vector2, in FP32Vector3 vector3, out FP32Vector3 result)
+        public static void GetMean3(in Vector3FP32 vector1, in Vector3FP32 vector2, in Vector3FP32 vector3, out Vector3FP32 result)
         {
-            result.x1 = (vector1.x1 + vector2.x1 + vector3.x1)  * FP32Utility.ONE_THIRD;
+            result.x1 = (vector1.x1 + vector2.x1 + vector3.x1)  * UtilityFP32.ONE_THIRD;
-            result.x2 = (vector1.x2 + vector2.x2 + vector3.x2)  * FP32Utility.ONE_THIRD;
+            result.x2 = (vector1.x2 + vector2.x2 + vector3.x2)  * UtilityFP32.ONE_THIRD;
-            result.x3 = (vector1.x3 + vector2.x3 + vector3.x3)  * FP32Utility.ONE_THIRD;
+            result.x3 = (vector1.x3 + vector2.x3 + vector3.x3)  * UtilityFP32.ONE_THIRD;
         }
 
-        public static float GetScalarProduct(in FP32Vector3 vector1, in FP32Vector3 vector2)
+        public static float GetScalarProduct(in Vector3FP32 vector1, in Vector3FP32 vector2)
         {
             return vector1.x1 * vector2.x1 + vector1.x2 * vector2.x2 + vector1.x3 * vector2.x3;
         }
  
-        public static void GetCrossProduct(in FP32Vector3 vector1, in FP32Vector3 vector2, out FP32Vector3 result)
+        public static void GetCrossProduct(in Vector3FP32 vector1, in Vector3FP32 vector2, out Vector3FP32 result)
         {
             float x1 = vector1.x2 * vector2.x3 - vector1.x3 * vector2.x2;
             float x2 = vector1.x3 * vector2.x1 - vector1.x1 * vector2.x3;
@@ -214,14 +213,14 @@ namespace BasicGeometry
             result.x3 = x3;
         }
 
-        public static float GetTripleProduct(in FP32Vector3 vector1, in FP32Vector3 vector2, in FP32Vector3 vector3)
+        public static float GetTripleProduct(in Vector3FP32 vector1, in Vector3FP32 vector2, in Vector3FP32 vector3)
         {
             return vector1.x1 * (vector2.x2 * vector3.x3 - vector2.x3 * vector3.x2)
                  + vector1.x2 * (vector2.x3 * vector3.x1 - vector2.x1 * vector3.x3)
                  + vector1.x3 * (vector2.x1 * vector3.x2 - vector2.x2 * vector3.x1);
         }
  
-        public static void GetDoubleCrossProduct(in FP32Vector3 vector1, in FP32Vector3 vector2, in FP32Vector3 vector3, out FP32Vector3 result)
+        public static void GetDoubleCrossProduct(in Vector3FP32 vector1, in Vector3FP32 vector2, in Vector3FP32 vector3, out Vector3FP32 result)
         {
             // [a x [b x c]] = b * (a, c) - c * (a, b)
             float ac = GetScalarProduct(vector1, vector3);
@@ -232,38 +231,38 @@ namespace BasicGeometry
             result.x3 = ac * vector2.x3 - ab * vector3.x3;
         }
 
-        public static float GetAngle(in FP32Vector3 vector1, in FP32Vector3 vector2, AngleUnit unit)
+        public static float GetAngle(in Vector3FP32 vector1, in Vector3FP32 vector2, AngleUnit unit)
         {
             float squareModule1 = vector1.GetSquareModule();
 
-            if (squareModule1 <= FP32Utility.SQUARE_EPSYLON)
+            if (squareModule1 <= UtilityFP32.SQUARE_EPSYLON)
             {
                 return 0.0f;
             }
 
             float squareModule2 = vector2.GetSquareModule();
 
-            if (squareModule2 <= FP32Utility.SQUARE_EPSYLON)
+            if (squareModule2 <= UtilityFP32.SQUARE_EPSYLON)
             {
                 return 0.0f;
             }
 
-            float cosine = FP32Vector3.GetScalarProduct(vector1, vector2) / MathF.Sqrt(squareModule1 * squareModule2);
+            float cosine = Vector3FP32.GetScalarProduct(vector1, vector2) / MathF.Sqrt(squareModule1 * squareModule2);
 
-            if (1.0f - FP32Utility.EPSYLON <= cosine)
+            if (1.0f - UtilityFP32.EPSYLON <= cosine)
             {
                 return 0.0f;
             }
 
-            if (cosine <= -(1.0f - FP32Utility.EPSYLON))
+            if (cosine <= -(1.0f - UtilityFP32.EPSYLON))
             {
-                return FP32Angle.GetHalfCircle(unit);
+                return AngleFP32.GetHalfCircle(unit);
             }
     
-            return FP32Radians.ToUnits(MathF.Acos(cosine), unit);
+            return RadianFP32.ToUnits(MathF.Acos(cosine), unit);
         }
     
-        public static float GetSquareDistance(in FP32Vector3 vector1, in FP32Vector3 vector2)
+        public static float GetSquareDistance(in Vector3FP32 vector1, in Vector3FP32 vector2)
         {
             float dx1 = vector1.x1 - vector2.x1;
             float dx2 = vector1.x2 - vector2.x2;
@@ -272,29 +271,29 @@ namespace BasicGeometry
             return dx1 * dx1 + dx2 * dx2 + dx3 * dx3;
         }
     
-        public static float GetDistance(in FP32Vector3 vector1, in FP32Vector3 vector2)
+        public static float GetDistance(in Vector3FP32 vector1, in Vector3FP32 vector2)
         {
             return MathF.Sqrt(GetSquareDistance(vector1, vector2));
         }
     
-        public static bool AreEqual(in FP32Vector3 vector1, in FP32Vector3 vector2)
+        public static bool AreEqual(in Vector3FP32 vector1, in Vector3FP32 vector2)
         {
             float squareModule1 = vector1.GetSquareModule();
             float squareModule2 = vector2.GetSquareModule();
             float squareModule3 = GetSquareDistance(vector1, vector2);
 
             // 3.0f means dimension amount
-            if (squareModule1 < FP32Utility.EPSYLON_EFFECTIVENESS_LIMIT || squareModule2 < FP32Utility.EPSYLON_EFFECTIVENESS_LIMIT)
+            if (squareModule1 < UtilityFP32.EPSYLON_EFFECTIVENESS_LIMIT || squareModule2 < UtilityFP32.EPSYLON_EFFECTIVENESS_LIMIT)
             {
-                return squareModule3 < (3.0f * FP32Utility.SQUARE_EPSYLON);
+                return squareModule3 < (3.0f * UtilityFP32.SQUARE_EPSYLON);
             }
 
             if (squareModule1 <= squareModule2)
             {
-                return squareModule3 <= (3.0f * FP32Utility.SQUARE_EPSYLON) * squareModule2;
+                return squareModule3 <= (3.0f * UtilityFP32.SQUARE_EPSYLON) * squareModule2;
             }
 
-            return squareModule3 <= (3.0f * FP32Utility.SQUARE_EPSYLON) * squareModule1;
+            return squareModule3 <= (3.0f * UtilityFP32.SQUARE_EPSYLON) * squareModule1;
         }
     }
 }

BasicGeometry/Vector3FP64.cs

@@ -23,29 +23,29 @@ using System;
 
 namespace BasicGeometry
 {
-    public struct FP64Vector3
+    public struct Vector3FP64
     {
-        public static readonly FP64Vector3 ZERO = new FP64Vector3(0.0, 0.0, 0.0);
+        public static readonly Vector3FP64 ZERO = new Vector3FP64(0.0, 0.0, 0.0);
 
         public double x1 = 0.0;
         public double x2 = 0.0;
         public double x3 = 0.0;
 
-        public FP64Vector3(double x1, double x2, double x3)
+        public Vector3FP64(double x1, double x2, double x3)
         {
             this.x1 = x1;
             this.x2 = x2;
             this.x3 = x3;
         }
 
-        public FP64Vector3(in FP64Vector3 vector)
+        public Vector3FP64(in Vector3FP64 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
             this.x3 = vector.x3;
         }
 
-        public FP64Vector3(in FP32Vector3 vector)
+        public Vector3FP64(in Vector3FP32 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
@@ -66,12 +66,13 @@ namespace BasicGeometry
         {
             double squareModule = this.GetSquareModule();
 
-            if (1.0 - FP64Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0 + FP64Utility.TWO_EPSYLON)
+            
+            if (UtilityFP64.IsSqareValueUnit(squareModule))
             {
                 return 1;
             }
 
-            if (squareModule <= FP64Utility.SQUARE_EPSYLON)
+            if (squareModule <= UtilityFP64.SQUARE_EPSYLON)
             {
                 this.Reset();
                 return 0;
@@ -95,13 +96,12 @@ namespace BasicGeometry
 
         public readonly bool IsZero()
         {
-            return this.GetSquareModule() <= FP64Utility.SQUARE_EPSYLON;
+            return this.GetSquareModule() <= UtilityFP64.SQUARE_EPSYLON;
         }
 
         public readonly bool IsUnit()
         {
-            double squareModule = this.GetSquareModule();
+            return UtilityFP64.IsSqareValueUnit(this.GetSquareModule());
-            return 1.0 - FP64Utility.TWO_EPSYLON <= squareModule && squareModule <= FP64Utility.EPSYLON;
         }
 
         public void Reset()
@@ -118,35 +118,35 @@ namespace BasicGeometry
             this.x3 = x3;
         }
 
-        public void SetValues(in FP64Vector3 vector)
+        public void SetValues(in Vector3FP64 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
             this.x3 = vector.x3;
         }
 
-        public void SetValues(in FP32Vector3 vector)
+        public void SetValues(in Vector3FP32 vector)
         {
             this.x1 = vector.x1;
             this.x2 = vector.x2;
             this.x3 = vector.x3;
         }
 
-        public void SetReverseOf(in FP64Vector3 vector)
+        public void SetReverseOf(in Vector3FP64 vector)
         {
             this.x1 = -vector.x1;
             this.x2 = -vector.x2;
             this.x3 = -vector.x3;
         }
 
-        public void SetReverseOf(in FP32Vector3 vector)
+        public void SetReverseOf(in Vector3FP32 vector)
         {
             this.x1 = -vector.x1;
             this.x2 = -vector.x2;
             this.x3 = -vector.x3;
         }
 
-        public void AppendScaled(FP64Vector3 summand, double scale)
+        public void AppendScaled(Vector3FP64 summand, double scale)
         {
             this.x1 += summand.x1 * scale;
             this.x2 += summand.x2 * scale;
@@ -158,52 +158,52 @@ namespace BasicGeometry
             return String.Format("DPVector3({0}, {1}, {2})", this.x1, this.x2, this.x3);
         }
 
-        public static void Add(in FP64Vector3 vector1, in FP64Vector3 vector2, out FP64Vector3 sum)
+        public static void Add(in Vector3FP64 vector1, in Vector3FP64 vector2, out Vector3FP64 sum)
         {
             sum.x1 = vector1.x1 + vector2.x1;
             sum.x2 = vector1.x2 + vector2.x2;
             sum.x3 = vector1.x3 + vector2.x3;
         }
 
-        public static void Subtract(in FP64Vector3 minuend, in FP64Vector3 subtrahend, out FP64Vector3 difference)
+        public static void Subtract(in Vector3FP64 minuend, in Vector3FP64 subtrahend, out Vector3FP64 difference)
         {
             difference.x1 = minuend.x1 - subtrahend.x1;
             difference.x2 = minuend.x2 - subtrahend.x2;
             difference.x3 = minuend.x3 - subtrahend.x3;
         }
 
-        public static void Multiply(in FP64Vector3 multiplicand, double multiplier, out FP64Vector3 product)
+        public static void Multiply(in Vector3FP64 multiplicand, double multiplier, out Vector3FP64 product)
         {
             product.x1 = multiplicand.x1 * multiplier;
             product.x2 = multiplicand.x2 * multiplier;
             product.x3 = multiplicand.x3 * multiplier;
         }
 
-        public static void Divide(in FP64Vector3 dividend, double divisor, out FP64Vector3 quotient)
+        public static void Divide(in Vector3FP64 dividend, double divisor, out Vector3FP64 quotient)
         {
             Multiply(dividend, 1.0 / divisor, out quotient);
         }
 
-        public static void GetMean2(in FP64Vector3 vector1, in FP64Vector3 vector2, out FP64Vector3 result)
+        public static void GetMean2(in Vector3FP64 vector1, in Vector3FP64 vector2, out Vector3FP64 result)
         {
             result.x1 = (vector1.x1 + vector2.x1) * 0.5;
             result.x2 = (vector1.x2 + vector2.x2) * 0.5;
             result.x3 = (vector1.x3 + vector2.x3) * 0.5;
         }
 
-        public static void GetMean3(in FP64Vector3 vector1, in FP64Vector3 vector2, in FP64Vector3 vector3, out FP64Vector3 result)
+        public static void GetMean3(in Vector3FP64 vector1, in Vector3FP64 vector2, in Vector3FP64 vector3, out Vector3FP64 result)
         {
-            result.x1 = (vector1.x1 + vector2.x1 + vector3.x1)  * FP64Utility.ONE_THIRD;
+            result.x1 = (vector1.x1 + vector2.x1 + vector3.x1)  * UtilityFP64.ONE_THIRD;
-            result.x2 = (vector1.x2 + vector2.x2 + vector3.x2)  * FP64Utility.ONE_THIRD;
+            result.x2 = (vector1.x2 + vector2.x2 + vector3.x2)  * UtilityFP64.ONE_THIRD;
-            result.x3 = (vector1.x3 + vector2.x3 + vector3.x3)  * FP64Utility.ONE_THIRD;
+            result.x3 = (vector1.x3 + vector2.x3 + vector3.x3)  * UtilityFP64.ONE_THIRD;
         }
 
-        public static double GetScalarProduct(in FP64Vector3 vector1, in FP64Vector3 vector2)
+        public static double GetScalarProduct(in Vector3FP64 vector1, in Vector3FP64 vector2)
         {
             return vector1.x1 * vector2.x1 + vector1.x2 * vector2.x2 + vector1.x3 * vector2.x3;
         }
  
-        public static void GetCrossProduct(in FP64Vector3 vector1, in FP64Vector3 vector2, out FP64Vector3 result)
+        public static void GetCrossProduct(in Vector3FP64 vector1, in Vector3FP64 vector2, out Vector3FP64 result)
         {
             double x1 = vector1.x2 * vector2.x3 - vector1.x3 * vector2.x2;
             double x2 = vector1.x3 * vector2.x1 - vector1.x1 * vector2.x3;
@@ -214,14 +214,14 @@ namespace BasicGeometry
             result.x3 = x3;
         }
 
-        public static double GetTripleProduct(in FP64Vector3 vector1, in FP64Vector3 vector2, in FP64Vector3 vector3)
+        public static double GetTripleProduct(in Vector3FP64 vector1, in Vector3FP64 vector2, in Vector3FP64 vector3)
         {
             return vector1.x1 * (vector2.x2 * vector3.x3 - vector2.x3 * vector3.x2)
                  + vector1.x2 * (vector2.x3 * vector3.x1 - vector2.x1 * vector3.x3)
                  + vector1.x3 * (vector2.x1 * vector3.x2 - vector2.x2 * vector3.x1);
         }
  
-        public static void GetDoubleCrossProduct(in FP64Vector3 vector1, in FP64Vector3 vector2, in FP64Vector3 vector3, out FP64Vector3 result)
+        public static void GetDoubleCrossProduct(in Vector3FP64 vector1, in Vector3FP64 vector2, in Vector3FP64 vector3, out Vector3FP64 result)
         {
             // [a x [b x c]] = b * (a, c) - c * (a, b)
             double ac = GetScalarProduct(vector1, vector3);
@@ -232,38 +232,38 @@ namespace BasicGeometry
             result.x3 = ac * vector2.x3 - ab * vector3.x3;
         }
 
-        public static double GetAngle(in FP64Vector3 vector1, in FP64Vector3 vector2, AngleUnit unit)
+        public static double GetAngle(in Vector3FP64 vector1, in Vector3FP64 vector2, AngleUnit unit)
         {
             double squareModule1 = vector1.GetSquareModule();
 
-            if (squareModule1 <= FP64Utility.SQUARE_EPSYLON)
+            if (squareModule1 <= UtilityFP64.SQUARE_EPSYLON)
             {
                 return 0.0;
             }
 
             double squareModule2 = vector2.GetSquareModule();
 
-            if (squareModule2 <= FP64Utility.SQUARE_EPSYLON)
+            if (squareModule2 <= UtilityFP64.SQUARE_EPSYLON)
             {
                 return 0.0;
             }
 
-            double cosine = FP64Vector3.GetScalarProduct(vector1, vector2) / Math.Sqrt(squareModule1 * squareModule2);
+            double cosine = Vector3FP64.GetScalarProduct(vector1, vector2) / Math.Sqrt(squareModule1 * squareModule2);
 
-            if (1.0 - FP64Utility.EPSYLON <= cosine)
+            if (1.0 - UtilityFP64.EPSYLON <= cosine)
             {
                 return 0.0;
             }
 
-            if (cosine <= -(1.0 - FP64Utility.EPSYLON))
+            if (cosine <= -(1.0 - UtilityFP64.EPSYLON))
             {
-                return FP64Angle.GetHalfCircle(unit);
+                return AngleFP64.GetHalfCircle(unit);
             }
     
-            return FP64Radians.ToUnits(Math.Acos(cosine), unit);
+            return RadianFP64.ToUnits(Math.Acos(cosine), unit);
         }
     
-        public static double GetSquareDistance(in FP64Vector3 vector1, in FP64Vector3 vector2)
+        public static double GetSquareDistance(in Vector3FP64 vector1, in Vector3FP64 vector2)
         {
             double dx1 = vector1.x1 - vector2.x1;
             double dx2 = vector1.x2 - vector2.x2;
@@ -272,29 +272,29 @@ namespace BasicGeometry
             return dx1 * dx1 + dx2 * dx2 + dx3 * dx3;
         }
     
-        public static double GetDistance(in FP64Vector3 vector1, in FP64Vector3 vector2)
+        public static double GetDistance(in Vector3FP64 vector1, in Vector3FP64 vector2)
         {
             return Math.Sqrt(GetSquareDistance(vector1, vector2));
         }
     
-        public static bool AreEqual(in FP64Vector3 vector1, in FP64Vector3 vector2)
+        public static bool AreEqual(in Vector3FP64 vector1, in Vector3FP64 vector2)
         {
             double squareModule1 = vector1.GetSquareModule();
             double squareModule2 = vector2.GetSquareModule();
             double squareModule3 = GetSquareDistance(vector1, vector2);
 
             // 3.0 means dimension amount
-            if (squareModule1 < FP64Utility.EPSYLON_EFFECTIVENESS_LIMIT || squareModule2 < FP64Utility.EPSYLON_EFFECTIVENESS_LIMIT)
+            if (squareModule1 < UtilityFP64.EPSYLON_EFFECTIVENESS_LIMIT || squareModule2 < UtilityFP64.EPSYLON_EFFECTIVENESS_LIMIT)
             {
-                return squareModule3 < (3.0 * FP64Utility.SQUARE_EPSYLON);
+                return squareModule3 < (3.0 * UtilityFP64.SQUARE_EPSYLON);
             }
 
             if (squareModule1 <= squareModule2)
             {
-                return squareModule3 <= (3.0 * FP64Utility.SQUARE_EPSYLON) * squareModule2;
+                return squareModule3 <= (3.0 * UtilityFP64.SQUARE_EPSYLON) * squareModule2;
             }
 
-            return squareModule3 <= (3.0 * FP64Utility.SQUARE_EPSYLON) * squareModule1;
+            return squareModule3 <= (3.0 * UtilityFP64.SQUARE_EPSYLON) * squareModule1;
         }
     }
 }

BasicGeometry/VersorFP32.cs

@@ -21,19 +21,19 @@
 
 namespace BasicGeometry
 {
-    public struct FP32Versor
+    public struct VersorFP32
     {
         private float s0 = 1.0f;
         private float x1 = 0.0f;
         private float x2 = 0.0f;
         private float x3 = 0.0f;
 
-        public FP32Versor(float s0, float x1, float x2, float x3)
+        public VersorFP32(float s0, float x1, float x2, float x3)
         {
             LoadValues(s0, x1, x2, x3, out this);
         }
 
-        public FP32Versor(in FP32Versor versor)
+        public VersorFP32(in VersorFP32 versor)
         {
             this.s0 = versor.s0;
             this.x1 = versor.x1;
@@ -41,7 +41,7 @@ namespace BasicGeometry
             this.x3 = versor.x3;
         }
 
-        public FP32Versor(in FP64Versor versor)
+        public VersorFP32(in VersorFP64 versor)
         {
             this.s0 = (float)versor.GetScalar();
             this.x1 = (float)versor.GetX1();
@@ -71,7 +71,7 @@ namespace BasicGeometry
 
         public readonly bool IsIdle()
         {
-            return this.s0 <= -(1.0f - FP32Utility.EPSYLON) || (1.0f - FP32Utility.EPSYLON) <= this.s0;
+            return this.s0 <= -(1.0f - UtilityFP32.EPSYLON) || (1.0f - UtilityFP32.EPSYLON) <= this.s0;
         }
 
         public void Reset()
@@ -101,19 +101,19 @@ namespace BasicGeometry
 
         public readonly float GetAngle(AngleUnit unit)
         {
-            if (this.s0 <= -(1.0f - FP32Utility.TWO_EPSYLON) || 1.0f - FP32Utility.TWO_EPSYLON <= this.s0) {
+            if (this.s0 <= -(1.0f - UtilityFP32.EPSYLON) || 1.0f - UtilityFP32.EPSYLON <= this.s0) {
                 return 0.0f;
             }
 
-            if (-FP32Utility.EPSYLON <= this.s0 && this.s0 <= FP32Utility.EPSYLON)
+            if (UtilityFP32.IsZero(this.s0))
             {
-                return FP32Angle.GetHalfCircle(unit);
+                return AngleFP32.GetHalfCircle(unit);
             }
 
-            return FP32Radians.ToUnits(2.0f * MathF.Acos(this.s0), unit);
+            return RadianFP32.ToUnits(2.0f * MathF.Acos(this.s0), unit);
         }
 
-        public readonly void MakeRotationMatrix(out FP32Matrix3x3 matrix)
+        public readonly void MakeRotationMatrix(out Matrix3x3FP32 matrix)
         {
             float s0s0 = this.s0 * this.s0;
             float x1x1 = this.x1 * this.x1;
@@ -141,7 +141,7 @@ namespace BasicGeometry
             matrix.r1c3 = x1x3 + s0x2;
         }
 
-        public readonly void MakeReverseMatrix(out FP32Matrix3x3 matrix)
+        public readonly void MakeReverseMatrix(out Matrix3x3FP32 matrix)
         {
             float s0s0 = this.s0 * this.s0;
             float x1x1 = this.x1 * this.x1;
@@ -178,15 +178,13 @@ namespace BasicGeometry
 
             float squareModule = (s0 * s0 + x1 * x1) + (x2 * x2 + x3 * x3);
             
-            if (1.0f - FP32Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0f + FP32Utility.TWO_EPSYLON)
+            if (!UtilityFP32.IsSqareValueUnit(squareModule))
             {
-                return;
+                this.Normalize(squareModule);
             }
-
-            this.Normalize(squareModule);
         }
 
-        public void SetValues(in FP32Versor versor)
+        public void SetValues(in VersorFP32 versor)
         {
             this.s0 = versor.s0;
             this.x1 = versor.x1;
@@ -194,7 +192,7 @@ namespace BasicGeometry
             this.x3 = versor.x3;
         }
 
-        public void SetValues(in FP64Versor versor)
+        public void SetValues(in VersorFP64 versor)
         {
             this.SetValues(
                 (float) versor.GetScalar(),
@@ -203,7 +201,7 @@ namespace BasicGeometry
                 (float) versor.GetX3());
         }
 
-        public void SetInverted(in FP32Versor versor)
+        public void SetInverted(in VersorFP32 versor)
         {
             this.s0 = versor.s0;
             this.x1 = -versor.x1;
@@ -211,7 +209,7 @@ namespace BasicGeometry
             this.x3 = -versor.x3;
         }
 
-        public void SetInverted(in FP64Versor versor)
+        public void SetInverted(in VersorFP64 versor)
         {
             this.SetValues(
                 (float)versor.GetScalar(),
@@ -220,7 +218,7 @@ namespace BasicGeometry
                 (float)-versor.GetX3());
         }
 
-        public void SetShortened(in FP32Versor versor)
+        public void SetShortened(in VersorFP32 versor)
         {
             if (versor.s0 < 0.0f)
             {
@@ -238,13 +236,13 @@ namespace BasicGeometry
             }
         }
 
-        public void SetShortened(in FP64Versor versor)
+        public void SetShortened(in VersorFP64 versor)
         {
             this.SetValues(versor);
             this.Shorten();
         }
 
-        public readonly void Turn(in FP32Vector3 vector, out FP32Vector3 result)
+        public readonly void Turn(in Vector3FP32 vector, out Vector3FP32 result)
         {
             float tx1 = 2.0f * (this.x2 * vector.x3 - this.x3 * vector.x2);
             float tx2 = 2.0f * (this.x3 * vector.x1 - this.x1 * vector.x3);
@@ -259,7 +257,7 @@ namespace BasicGeometry
             result.x3 = x3;
         }
 
-        public readonly void TurnBack(in FP32Vector3 vector, out FP32Vector3 result)
+        public readonly void TurnBack(in Vector3FP32 vector, out Vector3FP32 result)
         {
             float tx1 = 2.0f * (this.x2 * vector.x3 - this.x3 * vector.x2);
             float tx2 = 2.0f * (this.x3 * vector.x1 - this.x1 * vector.x3);
@@ -276,7 +274,7 @@ namespace BasicGeometry
 
         private void Normalize(float squareModule)
         {
-            if (squareModule <= FP32Utility.SQUARE_EPSYLON)
+            if (squareModule <= UtilityFP32.SQUARE_EPSYLON)
             {
                 this.Reset();
                 return;
@@ -290,7 +288,7 @@ namespace BasicGeometry
             this.x3 *= multiplier;
         }
 
-        public static void Combine(in FP32Versor second, in FP32Versor first, out FP32Versor result)
+        public static void Combine(in VersorFP32 second, in VersorFP32 first, out VersorFP32 result)
         {
             float s0 = (second.s0 * first.s0 - second.x1 * first.x1) - (second.x2 * first.x2 + second.x3 * first.x3);
             float x1 = (second.x1 * first.s0 + second.s0 * first.x1) - (second.x3 * first.x2 - second.x2 * first.x3);
@@ -304,15 +302,13 @@ namespace BasicGeometry
             result.x2 = x2;
             result.x3 = x3;
 
-            if (1.0f - FP32Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0f + FP32Utility.TWO_EPSYLON)
+            if (!UtilityFP32.IsSqareValueUnit(squareModule))
             {
-                return;
+                result.Normalize(squareModule);
             }
-
-            result.Normalize(squareModule);
         }
 
-        public static void LoadIdle(out FP32Versor versor)
+        public static void LoadIdle(out VersorFP32 versor)
         {
             versor.s0 = 1.0f;
             versor.x1 = 0.0f;
@@ -320,7 +316,7 @@ namespace BasicGeometry
             versor.x3 = 0.0f;
         }
         
-        public static void LoadValues(float s0, float x1, float x2, float x3, out FP32Versor versor)
+        public static void LoadValues(float s0, float x1, float x2, float x3, out VersorFP32 versor)
         {
             versor.s0 = s0;
             versor.x1 = x1;
@@ -329,12 +325,10 @@ namespace BasicGeometry
 
             float squareModule = (s0 * s0 + x1 * x1) + (x2 * x2 + x3 * x3);
             
-            if (1.0f - FP32Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0f + FP32Utility.TWO_EPSYLON)
+            if (!UtilityFP32.IsSqareValueUnit(squareModule))
             {
-                return;
+                versor.Normalize(squareModule);
             }
-
-            versor.Normalize(squareModule);
         }
     }
 }

BasicGeometry/VersorFP64.cs

@@ -22,19 +22,19 @@
 
 namespace BasicGeometry
 {
-    public struct FP64Versor
+    public struct VersorFP64
     {
         private double s0 = 1.0;
         private double x1 = 0.0;
         private double x2 = 0.0;
         private double x3 = 0.0;
 
-        public FP64Versor(double s0, double x1, double x2, double x3)
+        public VersorFP64(double s0, double x1, double x2, double x3)
         {
             LoadValues(s0, x1, x2, x3, out this);
         }
 
-        public FP64Versor(in FP64Versor versor)
+        public VersorFP64(in VersorFP64 versor)
         {
             this.s0 = versor.s0;
             this.x1 = versor.x1;
@@ -42,7 +42,7 @@ namespace BasicGeometry
             this.x3 = versor.x3;
         }
 
-        public FP64Versor(in FP32Versor versor)
+        public VersorFP64(in VersorFP32 versor)
         {
             LoadValues(versor.GetScalar(), versor.GetX1(), versor.GetX2(), versor.GetX3(), out this);
         }
@@ -69,7 +69,7 @@ namespace BasicGeometry
 
         public readonly bool IsIdle()
         {
-            return this.s0 <= -(1.0 - FP64Utility.EPSYLON) || (1.0 - FP64Utility.EPSYLON) <= this.s0;
+            return this.s0 <= -(1.0 - UtilityFP64.EPSYLON) || (1.0 - UtilityFP64.EPSYLON) <= this.s0;
         }
 
         public void Reset()
@@ -100,19 +100,19 @@ namespace BasicGeometry
 
         public readonly double GetAngle(AngleUnit unit)
         {
-            if (this.s0 <= -(1.0 - FP64Utility.TWO_EPSYLON) || 1.0 - FP64Utility.TWO_EPSYLON <= this.s0) {
+            if (this.s0 <= -(1.0 - UtilityFP64.EPSYLON) || 1.0 - UtilityFP64.EPSYLON <= this.s0) {
                 return 0.0;
             }
 
-            if (-FP64Utility.EPSYLON <= this.s0 && this.s0 <= FP64Utility.EPSYLON)
+            if (UtilityFP64.IsZero(this.s0))
             {
-                return FP64Angle.GetHalfCircle(unit);
+                return AngleFP64.GetHalfCircle(unit);
             }
 
-            return FP64Radians.ToUnits(2.0 * Math.Acos(this.s0), unit);
+            return RadianFP64.ToUnits(2.0 * Math.Acos(this.s0), unit);
         }
 
-        public readonly void MakeRotationMatrix(out FP64Matrix3x3 matrix)
+        public readonly void MakeRotationMatrix(out Matrix3x3FP64 matrix)
         {
             double s0s0 = this.s0 * this.s0;
             double x1x1 = this.x1 * this.x1;
@@ -141,7 +141,7 @@ namespace BasicGeometry
             matrix.r1c3 = x1x3 + s0x2;
         }
 
-        public readonly void MakeReverseMatrix(out FP64Matrix3x3 matrix)
+        public readonly void MakeReverseMatrix(out Matrix3x3FP64 matrix)
         {
             double s0s0 = this.s0 * this.s0;
             double x1x1 = this.x1 * this.x1;
@@ -178,15 +178,13 @@ namespace BasicGeometry
             
             double squareModule = (s0 * s0 + x1 * x1) + (x2 * x2 + x3 * x3);
             
-            if (1.0 - FP64Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0 + FP64Utility.TWO_EPSYLON)
+            if (!UtilityFP64.IsSqareValueUnit(squareModule))
             {
-                return;
+                this.Normalize(squareModule);
             }
-
-            this.Normalize(squareModule);
         }
 
-        public void SetValues(in FP64Versor versor)
+        public void SetValues(in VersorFP64 versor)
         {
             this.s0 = versor.s0;
             this.x1 = versor.x1;
@@ -194,12 +192,12 @@ namespace BasicGeometry
             this.x3 = versor.x3;
         }
 
-        public void SetValues(in FP32Versor versor)
+        public void SetValues(in VersorFP32 versor)
         {
             this.SetValues(versor.GetScalar(), versor.GetX1(), versor.GetX2(), versor.GetX3());
         }
 
-        public void SetShortened(in FP64Versor versor)
+        public void SetShortened(in VersorFP64 versor)
         {
             if (versor.s0 < 0.0)
             {
@@ -217,13 +215,13 @@ namespace BasicGeometry
             }
         }
 
-        public void SetShortened(in FP32Versor versor)
+        public void SetShortened(in VersorFP32 versor)
         {
             this.SetValues(versor);
             this.Shorten();
         }
 
-        public void SetInverted(in FP64Versor versor)
+        public void SetInverted(in VersorFP64 versor)
         {
             this.s0 = versor.s0;
             this.x1 = -versor.x1;
@@ -231,12 +229,12 @@ namespace BasicGeometry
             this.x3 = -versor.x3;
         }
 
-        public void SetInverted(in FP32Versor versor)
+        public void SetInverted(in VersorFP32 versor)
         {
             this.SetValues(versor.GetScalar(), -versor.GetX1(), -versor.GetX2(), -versor.GetX3());
         }
 
-        public readonly void Turn(in FP64Vector3 vector, out FP64Vector3 result)
+        public readonly void Turn(in Vector3FP64 vector, out Vector3FP64 result)
         {
             double tx1 = 2.0 * (this.x2 * vector.x3 - this.x3 * vector.x2);
             double tx2 = 2.0 * (this.x3 * vector.x1 - this.x1 * vector.x3);
@@ -251,7 +249,7 @@ namespace BasicGeometry
             result.x3 = x3;
         }
 
-        public readonly void TurnBack(in FP64Vector3 vector, out FP64Vector3 result)
+        public readonly void TurnBack(in Vector3FP64 vector, out Vector3FP64 result)
         {
             double tx1 = 2.0 * (this.x2 * vector.x3 - this.x3 * vector.x2);
             double tx2 = 2.0 * (this.x3 * vector.x1 - this.x1 * vector.x3);
@@ -268,7 +266,7 @@ namespace BasicGeometry
 
         private void Normalize(double squareModule)
         {
-            if (squareModule <= FP64Utility.SQUARE_EPSYLON || (this.x1 * this.x1 + this.x2 * this.x2 + this.x3 * this.x3) <= FP64Utility.SQUARE_EPSYLON * squareModule)
+            if (squareModule <= UtilityFP64.SQUARE_EPSYLON || (this.x1 * this.x1 + this.x2 * this.x2 + this.x3 * this.x3) <= UtilityFP64.SQUARE_EPSYLON * squareModule)
             {
                 this.Reset();
                 return;
@@ -282,7 +280,7 @@ namespace BasicGeometry
             this.x3 *= multiplier;
         }
 
-        public static void Combine(in FP64Versor second, in FP64Versor first, out FP64Versor result)
+        public static void Combine(in VersorFP64 second, in VersorFP64 first, out VersorFP64 result)
         {
             double s0 = (second.s0 * first.s0 - second.x1 * first.x1) - (second.x2 * first.x2 + second.x3 * first.x3);
             double x1 = (second.x1 * first.s0 + second.s0 * first.x1) - (second.x3 * first.x2 - second.x2 * first.x3);
@@ -296,15 +294,13 @@ namespace BasicGeometry
             result.x2 = x2;
             result.x3 = x3;
 
-            if (1.0 - FP64Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0 + FP64Utility.TWO_EPSYLON)
+            if (!UtilityFP64.IsSqareValueUnit(squareModule))
             {
-                return;
+                result.Normalize(squareModule);
             }
-
-            result.Normalize(squareModule);
         }
 
-        public static void LoadIdle(out FP64Versor versor)
+        public static void LoadIdle(out VersorFP64 versor)
         {
             versor.s0 = 1.0;
             versor.x1 = 0.0;
@@ -312,7 +308,7 @@ namespace BasicGeometry
             versor.x3 = 0.0;
         }
         
-        public static void LoadValues(double s0, double x1, double x2, double x3, out FP64Versor versor)
+        public static void LoadValues(double s0, double x1, double x2, double x3, out VersorFP64 versor)
         {
             versor.s0 = s0;
             versor.x1 = x1;
@@ -321,12 +317,10 @@ namespace BasicGeometry
 
             double squareModule = (s0 * s0 + x1 * x1) + (x2 * x2 + x3 * x3);
             
-            if (1.0 - FP64Utility.TWO_EPSYLON <= squareModule && squareModule <= 1.0 + FP64Utility.TWO_EPSYLON)
+            if (!UtilityFP64.IsSqareValueUnit(squareModule))
             {
-                return;
+                versor.Normalize(squareModule);
             }
-
-            versor.Normalize(squareModule);
         }
     }
 }

BasicGeometryDev/Program.cs

@@ -6,14 +6,14 @@ using BasicGeometry;
 
 public static class Program
 {
-    private static FP32Versor[] AllocateVersors(int amount)
+    private static VersorFP32[] AllocateVersors(int amount)
     {
-        return new FP32Versor[amount];
+        return new VersorFP32[amount];
     }
 
-    private static FP32Versor[] MakeZeroVersors(int amount)
+    private static VersorFP32[] MakeZeroVersors(int amount)
     {
-        FP32Versor[] versors = AllocateVersors(amount);
+        VersorFP32[] versors = AllocateVersors(amount);
 
         for (int i = 0; i < amount; i++)
         {
@@ -23,15 +23,15 @@ public static class Program
         return versors;
     }
 
-    private static FP32Versor[] MakeRandomVersors(int amount)
+    private static VersorFP32[] MakeRandomVersors(int amount)
     {
         Random randomizer = new Random(Environment.TickCount);
 
-        FP32Versor[] versors = AllocateVersors(amount);
+        VersorFP32[] versors = AllocateVersors(amount);
 
         for (int i = 0; i < amount; i++)
         {
-            versors[i] = new FP32Versor(
+            versors[i] = new VersorFP32(
                 randomizer.NextSingle(),
                 randomizer.NextSingle(),
                 randomizer.NextSingle(),
@@ -42,7 +42,7 @@ public static class Program
         return versors;
     }
 
-    private static void PrintVersor(in FP32Versor versor)
+    private static void PrintVersor(in VersorFP32 versor)
     {
         Console.WriteLine("({0}, {1}, {2}, {3})", versor.GetScalar(), versor.GetX1(), versor.GetX2(), versor.GetX3());
     }
@@ -51,9 +51,9 @@ public static class Program
     {
         int amount = 1000000;
         
-        FP32Versor[] versors1 = MakeRandomVersors(amount);
+        VersorFP32[] versors1 = MakeRandomVersors(amount);
-        FP32Versor[] versors2 = MakeRandomVersors(amount);
+        VersorFP32[] versors2 = MakeRandomVersors(amount);
-        FP32Versor[] results = MakeZeroVersors(amount);
+        VersorFP32[] results = MakeZeroVersors(amount);
 
         long start, end;
 
@@ -63,7 +63,7 @@ public static class Program
         {
             for (int i = 0; i < amount; i++)
             {
-                FP32Versor.Combine(versors1[i], versors2[i], out results[i]);
+                VersorFP32.Combine(versors1[i], versors2[i], out results[i]);
             }
         }
 

BasicGeometryTest/F32Vector2Test.cs

@@ -1,19 +0,0 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-using System;
-using System.IO;
-
-using BasicGeometry;
-
-namespace BasicGeometryTest
-{
-    [TestClass]
-    public class FP32Vector2Test
-    {
-        [TestMethod]
-        public void TestInitialization()
-        {
-            FP32Vector2 vector = new FP32Vector2(1.0f, 2.0f);
-        }
-    }
-}

BasicGeometryTest/TestVector2FP32.cs

@@ -0,0 +1,27 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using System;
+using System.IO;
+
+using BasicGeometry;
+
+namespace BasicGeometryTest
+{
+    [TestClass]
+    public class TestVector2FP32
+    {
+        [TestMethod]
+        public void TestReset()
+        {
+            Vector2FP32 vector = new Vector2FP32(1.0f, 2.0f);
+
+            Assert.AreEqual(vector.x1, 1.0f);
+            Assert.AreEqual(vector.x2, 2.0f);
+
+            vector.Reset();
+
+            Assert.AreEqual(vector.x1, 0.0f);
+            Assert.AreEqual(vector.x2, 0.0f);
+        }
+    }
+}