Merge pull request #16 from laicasaane/master

Add functionality & restructure the project

Author: ltmx

.gitignore

@@ -0,0 +1,2 @@
+*.csproj
+*.csproj.meta

Runtime/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Mathematics.Mathx.Tests")]

Runtime/AssemblyInfo.cs.meta

@@ -3,7 +3,6 @@
     "rootNamespace": "",
     "references": [
         "GUID:d8b63aba1907145bea998dd612889d6b",
-        "GUID:343deaaf83e0cee4ca978e7df0b80d21",
         "GUID:2bafac87e7f4b9b418d9448d219b01ab",
         "GUID:2665a8d13d1b3f18800f46e256720795"
     ],

Mathematics.Mathx.asmdef Runtime/Mathematics.Mathx.asmdefMathematics.Mathx.asmdef renamed to Runtime/Mathematics.Mathx.asmdef

@@ -293,5 +293,11 @@ public static partial class mathx
         /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
         /// that are only reduced to a narrow uint hash at the very end instead of at every step.
         [MethodImpl(INLINE)] public static uint2 hashwide(byte2 v) => uint2(v.x, v.y) * uint2(0xEBD0D005u, 0x91475DF7u) + 0x55E84827u;
+
+
+        /// <inheritdoc cref="subx(byte4, byte)"/>
+        [MethodImpl(IL)] public static byte2 subx(this byte2 f, byte x) => new(x, f.y);
+        /// <inheritdoc cref="suby(byte4, byte)"/>
+        [MethodImpl(IL)] public static byte2 suby(this byte2 f, byte y) => new(f.x, y);
     }
 }

Mathematics.Mathx.asmdef.meta Runtime/Mathematics.Mathx.asmdef.metaMathematics.Mathx.asmdef.meta renamed to Runtime/Mathematics.Mathx.asmdef.meta

@@ -709,5 +709,13 @@ public static partial class mathx
 
         /// Returns a uint3 vector hash code of a byte3 vector.
         [MethodImpl(INLINE)] public static uint3 hashwide(byte3 v) => uint3(v.x, v.y, v.z) * uint3(0xFA3A3285u, 0xAD55999Du, 0xDCDD5341u) + 0x94DDD769u;
+
+
+        /// <inheritdoc cref="subx(byte4, byte)"/>
+        [MethodImpl(IL)] public static byte3 subx(this byte3 f, byte x) => new(x, f.y, f.z);
+        /// <inheritdoc cref="suby(byte4, byte)"/>
+        [MethodImpl(IL)] public static byte3 suby(this byte3 f, byte y) => new(f.x, y, f.z);
+        /// <inheritdoc cref="subz(byte4, byte)"/>
+        [MethodImpl(IL)] public static byte3 subz(this byte3 f, byte z) => new(f.x, f.y, z);
     }
 }

Runtime/Structs/byte2.cs

@@ -1859,5 +1859,15 @@ public static partial class mathx
         /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
         /// that are only reduced to a narrow uint hash at the very end instead of at every step.
         [MethodImpl(INLINE)] public static uint4 hashwide(byte4 v) => v * uint4(0xBC3B0A59u, 0x816EFB5Du, 0xA24E82B7u, 0x45A22087u) + 0xFC104C3Bu;
+
+
+        /// substitutes the component x
+        [MethodImpl(IL)] public static byte4 subx(this byte4 f, byte x) => new(x, f.y, f.z, f.w);
+        /// substitutes the component y
+        [MethodImpl(IL)] public static byte4 suby(this byte4 f, byte y) => new(f.x, y, f.z, f.w);
+        /// substitutes the component z
+        [MethodImpl(IL)] public static byte4 subz(this byte4 f, byte z) => new(f.x, f.y, z, f.w);
+        /// substitutes the component w
+        [MethodImpl(IL)] public static byte4 subw(this byte4 f, byte w) => new(f.x, f.y, f.z, w);
     }
 }

Runtime/Structs/byte3.cs

@@ -1627,5 +1627,15 @@ public static partial class mathx
         [MethodImpl(INLINE)] public static float lineartogama(this float c) => c.pow(1 / 2.2f);
         [MethodImpl(INLINE)] public static color gammatolinear(this color c) => new(c.x.gammatolinear(), c.y.gammatolinear(), c.z.gammatolinear(), c.w);
         [MethodImpl(INLINE)] public static color lineartogama(this color c) => new(c.x.lineartogama(), c.y.lineartogama(), c.z.lineartogama(), c.w);
+
+
+        /// substitutes the component x
+        [MethodImpl(IL)] public static color subx(this color f, float x) => new(x, f.y, f.z, f.w);
+        /// substitutes the component y
+        [MethodImpl(IL)] public static color suby(this color f, float y) => new(f.x, y, f.z, f.w);
+        /// substitutes the component z
+        [MethodImpl(IL)] public static color subz(this color f, float z) => new(f.x, f.y, z, f.w);
+        /// substitutes the component w
+        [MethodImpl(IL)] public static color subw(this color f, float w) => new(f.x, f.y, f.z, w);
     }
 }

Runtime/Structs/byte4.cs

@@ -383,5 +383,25 @@ public static partial class mathx
         [MethodImpl(IL)] public static double3 cycle(this double3 f, int n) => f.apply(cycle, n);
         /// applies a function to a double4 n times
         [MethodImpl(IL)] public static double4 cycle(this double4 f, int n) => f.apply(cycle, n);
+
+
+        /// <inheritdoc cref="subx(double4, double)"/>
+        [MethodImpl(IL)] public static double2 subx(this double2 f, double x) => new(x, f.y);
+        /// <inheritdoc cref="suby(double4, double)"/>
+        [MethodImpl(IL)] public static double2 suby(this double2 f, double y) => new(f.x, y);
+        /// <inheritdoc cref="subx(double4, double)"/>
+        [MethodImpl(IL)] public static double3 subx(this double3 f, double x) => new(x, f.y, f.z);
+        /// <inheritdoc cref="suby(double4, double)"/>
+        [MethodImpl(IL)] public static double3 suby(this double3 f, double y) => new(f.x, y, f.z);
+        /// <inheritdoc cref="subz(double4, double)"/>
+        [MethodImpl(IL)] public static double3 subz(this double3 f, double z) => new(f.x, f.y, z);
+        /// substitutes the component x
+        [MethodImpl(IL)] public static double4 subx(this double4 f, double x) => new(x, f.y, f.z, f.w);
+        /// substitutes the component y
+        [MethodImpl(IL)] public static double4 suby(this double4 f, double y) => new(f.x, y, f.z, f.w);
+        /// substitutes the component z
+        [MethodImpl(IL)] public static double4 subz(this double4 f, double z) => new(f.x, f.y, z, f.w);
+        /// substitutes the component w
+        [MethodImpl(IL)] public static double4 subw(this double4 f, double w) => new(f.x, f.y, f.z, w);
     }
 }