add generator

otac0n · May 28, 2025 · May 28, 2025 · May 28, 2025 · May 28, 2025 · May 28, 2025
commit 129207c138c10f3055f81bcdca36a3ca02528e7f
@@ -0,0 +1,4 @@
+.vs/
+bin/
+obj/
+/DemoLibrary/**/*.cs
@@ -0,0 +1,24 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 18
+VisualStudioVersion = 18.3.11505.172 d18.3
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GenerateMatrixMath", "GenerateMatrixMath\GenerateMatrixMath.csproj", "{505330B8-C28A-4E36-AC44-3C48BF551B34}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{505330B8-C28A-4E36-AC44-3C48BF551B34}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{505330B8-C28A-4E36-AC44-3C48BF551B34}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{505330B8-C28A-4E36-AC44-3C48BF551B34}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{505330B8-C28A-4E36-AC44-3C48BF551B34}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {6A29E176-1DE7-4A4E-A935-7B5D223FEFE9}
+	EndGlobalSection
+EndGlobal
@@ -48,7 +48,7 @@ static void Main()
             };
 
             var outputPaths = new[] {
-                @"C:\Users\otac0n\Projects\Silk.NET\sources\Maths\Maths\",
+                @"W:\projects\Silk.NET\sources\Maths\Maths\",
             };
 
             var dims = new HashSet<Dimension>();

@@ -26,6 +26,7 @@ namespace Silk.NET.Maths
     using System;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.CompilerServices;
     using System.Runtime.Serialization;
 
     /// <summary>A structure encapsulating a {{= size}} matrix.</summary>
@@ -186,56 +187,126 @@ namespace Silk.NET.Maths
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==({{@Name thisType}}<T> left, {{@Name thisType}}<T> right) =>
-            {{each r in rows}}left.Row{{= r}} == right.Row{{= r}}{{delimit}} &&
-            {{/each}};
+        {{if generateNumericsCast}}
+            public static bool operator ==({{@Name thisType}}<T> left, {{@Name thisType}}<T> right)
+            {
+                if (typeof(T) == typeof(float))
+                    return Unsafe.BitCast<{{@Name thisType}}<T>, {{= numericsName}}>(left) == Unsafe.BitCast<{{@Name thisType}}<T>, {{= numericsName}}>(right);
+                return {{each r in rows}}left.Row{{= r}} == right.Row{{= r}}{{delimit}} &&
+                {{/each}};
+            }
+        {{else}}
+            public static bool operator ==({{@Name thisType}}<T> left, {{@Name thisType}}<T> right) =>
+                {{each r in rows}}left.Row{{= r}} == right.Row{{= r}}{{delimit}} &&
+                {{/each}};
+        {{/if}}
 
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=({{@Name thisType}}<T> left, {{@Name thisType}}<T> right) =>
-            {{each r in rows}}left.Row{{= r}} != right.Row{{= r}}{{delimit}} ||
-            {{/each}};
+        {{if generateNumericsCast}}
+            public static bool operator !=({{@Name thisType}}<T> left, {{@Name thisType}}<T> right)
+            {
+                if (typeof(T) == typeof(float))
+                    return Unsafe.BitCast<{{@Name thisType}}<T>, {{= numericsName}}>(left) != Unsafe.BitCast<{{@Name thisType}}<T>, {{= numericsName}}>(right);
+                return {{each r in rows}}left.Row{{= r}} != right.Row{{= r}}{{delimit}} ||
+                {{/each}};
+            }
+        {{else}}
+            public static bool operator !=({{@Name thisType}}<T> left, {{@Name thisType}}<T> right) =>
+                {{each r in rows}}left.Row{{= r}} != right.Row{{= r}}{{delimit}} ||
+                {{/each}};
+        {{/if}}
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static {{@Name thisType}}<T> operator +({{@Name thisType}}<T> left, {{@Name thisType}}<T> right) =>
-            new({{each r in rows}}left.Row{{= r}} + right.Row{{= r}}{{delimit}},
-                {{/each}});
+        {{if generateNumericsCast}}
+            public static {{@Name thisType}}<T> operator +({{@Name thisType}}<T> left, {{@Name thisType}}<T> right)
+            {
+                if (typeof(T) == typeof(float))
+                    return Unsafe.BitCast<{{= numericsName}}, {{@Name thisType}}<T>>(Unsafe.BitCast<{{@Name thisType}}<T>, {{= numericsName}}>(left) + Unsafe.BitCast<{{@Name thisType}}<T>, {{= numericsName}}>(right));
+                return new({{each r in rows}}left.Row{{= r}} + right.Row{{= r}}{{delimit}},
+                    {{/each}});
+            }
+        {{else}}
+            public static {{@Name thisType}}<T> operator +({{@Name thisType}}<T> left, {{@Name thisType}}<T> right) =>
+                new({{each r in rows}}left.Row{{= r}} + right.Row{{= r}}{{delimit}},
+                    {{/each}});
+        {{/if}}
 
         /// <summary>Subtracts the second matrix from the first.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static {{@Name thisType}}<T> operator -({{@Name thisType}}<T> left, {{@Name thisType}}<T> right) =>
-            new({{each r in rows}}left.Row{{= r}} - right.Row{{= r}}{{delimit}},
-                {{/each}});
+        {{if generateNumericsCast}}
+            public static {{@Name thisType}}<T> operator -({{@Name thisType}}<T> left, {{@Name thisType}}<T> right)
+            {
+                if (typeof(T) == typeof(float))
+                    return Unsafe.BitCast<{{= numericsName}}, {{@Name thisType}}<T>>(Unsafe.BitCast<{{@Name thisType}}<T>, {{= numericsName}}>(left) - Unsafe.BitCast<{{@Name thisType}}<T>, {{= numericsName}}>(right));
+                return new({{each r in rows}}left.Row{{= r}} - right.Row{{= r}}{{delimit}},
+                    {{/each}});
+            }
+        {{else}}
+            public static {{@Name thisType}}<T> operator -({{@Name thisType}}<T> left, {{@Name thisType}}<T> right) =>
+                new({{each r in rows}}left.Row{{= r}} - right.Row{{= r}}{{delimit}},
+                    {{/each}});
+        {{/if}}
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
         /// <param name="value">The source matrix.</param>
         /// <returns>The negated matrix.</returns>
-        public static {{@Name thisType}}<T> operator -({{@Name thisType}}<T> value) =>
-            new({{each r in rows}}-value.Row{{= r}}{{delimit}},
-                {{/each}});
+        {{if generateNumericsCast}}
+            public static {{@Name thisType}}<T> operator -({{@Name thisType}}<T> value)
+            {
+                if (typeof(T) == typeof(float))
+                    return Unsafe.BitCast<{{= numericsName}}, {{@Name thisType}}<T>>(-Unsafe.BitCast<{{@Name thisType}}<T>, {{= numericsName}}>(value));
+                return new({{each r in rows}}-value.Row{{= r}}{{delimit}},
+                    {{/each}});
+            }
+        {{else}}
+            public static {{@Name thisType}}<T> operator -({{@Name thisType}}<T> value) =>
+                new({{each r in rows}}-value.Row{{= r}}{{delimit}},
+                    {{/each}});
+        {{/if}}
 
         /// <summary>Multiplies a matrix by a scalar value.</summary>
         /// <param name="left">The scaling factor.</param>
         /// <param name="right">The source matrix.</param>
         /// <returns>The scaled matrix.</returns>
-        public static {{@Name thisType}}<T> operator *(T left, {{@Name thisType}}<T> right) =>
-            new({{each r in rows}}left * right.Row{{= r}}{{delimit}},
-                {{/each}});
+        {{if generateNumericsCast}}
+            public static {{@Name thisType}}<T> operator *(T left, {{@Name thisType}}<T> right)
+            {
+                if (typeof(T) == typeof(float))
+                    return Unsafe.BitCast<{{= numericsName}}, {{@Name thisType}}<T>>(Unsafe.BitCast<{{@Name thisType}}<T>, {{= numericsName}}>(right) * Unsafe.BitCast<T, float>(left));
+                return new({{each r in rows}}left * right.Row{{= r}}{{delimit}},
+                    {{/each}});
+            }
+        {{else}}
+            public static {{@Name thisType}}<T> operator *(T left, {{@Name thisType}}<T> right) =>
+                new({{each r in rows}}left * right.Row{{= r}}{{delimit}},
+                    {{/each}});
+        {{/if}}
 
         /// <summary>Multiplies a matrix by a scalar value.</summary>
         /// <param name="left">The source matrix.</param>
         /// <param name="right">The scaling factor.</param>
         /// <returns>The scaled matrix.</returns>
-        public static {{@Name thisType}}<T> operator *({{@Name thisType}}<T> left, T right) =>
-            new({{each r in rows}}left.Row{{= r}} * right{{delimit}},
-                {{/each}});
+        {{if generateNumericsCast}}
+            public static {{@Name thisType}}<T> operator *({{@Name thisType}}<T> left, T right)
+            {
+                if (typeof(T) == typeof(float))
+                    return Unsafe.BitCast<{{= numericsName}}, {{@Name thisType}}<T>>(Unsafe.BitCast<{{@Name thisType}}<T>, {{= numericsName}}>(left) * Unsafe.BitCast<T, float>(right));
+                return new({{each r in rows}}left.Row{{= r}} * right{{delimit}},
+                    {{/each}});
+            }
+        {{else}}
+            public static {{@Name thisType}}<T> operator *({{@Name thisType}}<T> left, T right) =>
+                new({{each r in rows}}left.Row{{= r}} * right{{delimit}},
+                    {{/each}});
+        {{/if}}
 
         {{if size.Columns < 5 && size.Rows < 5}}
             {{

@@ -22,6 +22,7 @@
 namespace Silk.NET.Maths
 {
     using System.Numerics;
+    using System.Runtime.CompilerServices;
 
     /// <summary>
     /// Methods for working with <see cref="{{@Name thisType}}{T}"/>.