API Implementation: Add Indexer to Vectors (dotnet#60517)

* Add indexer for Vector2

* Add indexer for Vector3

* Add indexer for Vector4

* Add indexer for Quaternion

* Add indexer for Matrix3x2

* Add indexer for Matrix4x4

* Add indexer for Vector64<T>, Vector128<T> and Vector256<T>

* Implement better codegen

* Replace switch-tree by if-else-construct and add add Debug.Assert call to indexer of Matrix3x2

* More performant indexer implementation for Vector64<T>

* Improve performance of Indexers for Vector64<T>, Vector128<T> and Vector256<T>

* Improve code readability

* Easier index implementation for Vector64<T>, Vector128<T> and Vector256<T>

* Implement slimmer index implementation for Matrix3x2<T> and Matrix4x4<T>

* Implement GetElement/SetElement on various types

* Usage of Vector2 instead of Vector4

* Implement GetElement/SetElement for Vector2 and Vector3

* Remove setters

* Made Count const in Vector2, Vector3 and Vector4

* Implement GetElement/WithElement Extensions for Quaternion, Vector2, Vector3 and Vector4

* Setter implementation for Matrix3x2 and Matrix4x4

* Fix Quaternion

* Clone vectors in WithElement of QuaternionExtensions, Vector2Extensions, Vector3Extensions, Vector4Extensions

* Make QuaternionExtensions, Vector2Extensions, Vector3Extensions and Vector4Extensions internal

* Replace Extension Methods with normal static methods in Quaternion, Vector2, Vector3 and Vector4

* Make WithElement public and SetElementUnsafe internal in Quaternion, Vector2, Vector3 and Vector4

* Add methods and indexers to references

* Fix Matrix3x2 and Matrix4x4

* Update that the setter of Quaternion, Vector2, Vector3 and Vector4 sets `this` to the result of WithElement

* Simplify SetElementUnsafe in Vector2, Vector3 and Vector4

* Simplify SetElementUnsafe in Quaternion

* Add test cases for Matrix3x2, Matrix4x4, Quaternion, Vector2, Vector3 and Vector4

* Add indexer to reference for Vector64<T>, Vector128<T> and Vector256<T>

* Fix solution file

* Make WithElement in Quaternion, Vector2, Vector3 and Vector4 internal

* Fix project file of System.Private.CoreLib.Shared

* Fix indentation in System.Numerics.Vectors reference

* Code improvements

* Fix solution file

* Remove unsafe from reference

* Add Tests for Vector64<T>, Vector128<T> and Vector256<T>

* Create Test project for System.Runtime.Intrinsics and move vector tests from System.Runtime to System.Runtime.Intrinsics

* Fix test cases

* recreate System.Runtime.sln

* Fix System.Runtime.sln and remove old Vector Tests

* Implement usage of ThrowHelper for Matrix3x2 and Matrix4x4

* Replace Assert.All over array by Assert.Equal in Vector128Tests

* Replace Assert.All over array by Assert.Equal in Vector256Tests

* Replace Assert.All over array by Assert.Equal in Vector64Tests

* Fix indexer tests for Vector64<T>

* Fix indexer tests for Vector128<T>

* Fix indexer tests for Vector256<T>

* Fix indexer of Matrix3x2

* Fix indexer of Matrix4x4

Author: deeprobin

src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs

@@ -16,6 +16,7 @@ public partial struct Matrix3x2 : System.IEquatable<System.Numerics.Matrix3x2>
         public float M32;
         public Matrix3x2(float m11, float m12, float m21, float m22, float m31, float m32) { throw null; }
         public static System.Numerics.Matrix3x2 Identity { get { throw null; } }
+        public float this[int row, int column] { get { throw null; } set { throw null; } }
         public readonly bool IsIdentity { get { throw null; } }
         public System.Numerics.Vector2 Translation { readonly get { throw null; } set { } }
         public static System.Numerics.Matrix3x2 Add(System.Numerics.Matrix3x2 value1, System.Numerics.Matrix3x2 value2) { throw null; }
@@ -71,6 +72,7 @@ public partial struct Matrix4x4 : System.IEquatable<System.Numerics.Matrix4x4>
         public Matrix4x4(System.Numerics.Matrix3x2 value) { throw null; }
         public Matrix4x4(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44) { throw null; }
         public static System.Numerics.Matrix4x4 Identity { get { throw null; } }
+        public float this[int row, int column] { get { throw null; } set { throw null; } }
         public readonly bool IsIdentity { get { throw null; } }
         public System.Numerics.Vector3 Translation { readonly get { throw null; } set { } }
         public static System.Numerics.Matrix4x4 Add(System.Numerics.Matrix4x4 value1, System.Numerics.Matrix4x4 value2) { throw null; }
@@ -155,6 +157,7 @@ public partial struct Quaternion : System.IEquatable<System.Numerics.Quaternion>
         public Quaternion(float x, float y, float z, float w) { throw null; }
         public static System.Numerics.Quaternion Zero { get { throw null; } }
         public static System.Numerics.Quaternion Identity { get { throw null; } }
+        public float this[int index] { get { throw null; } set { throw null; } }
         public readonly bool IsIdentity { get { throw null; } }
         public static System.Numerics.Quaternion Add(System.Numerics.Quaternion value1, System.Numerics.Quaternion value2) { throw null; }
         public static System.Numerics.Quaternion Concatenate(System.Numerics.Quaternion value1, System.Numerics.Quaternion value2) { throw null; }
@@ -313,6 +316,7 @@ public partial struct Vector2 : System.IEquatable<System.Numerics.Vector2>, Syst
         public static System.Numerics.Vector2 One { get { throw null; } }
         public static System.Numerics.Vector2 UnitX { get { throw null; } }
         public static System.Numerics.Vector2 UnitY { get { throw null; } }
+        public float this[int index] { get { throw null; } set { throw null; } }
         public static System.Numerics.Vector2 Zero { get { throw null; } }
         public static System.Numerics.Vector2 Abs(System.Numerics.Vector2 value) { throw null; }
         public static System.Numerics.Vector2 Add(System.Numerics.Vector2 left, System.Numerics.Vector2 right) { throw null; }
@@ -374,6 +378,7 @@ public partial struct Vector3 : System.IEquatable<System.Numerics.Vector3>, Syst
         public static System.Numerics.Vector3 UnitX { get { throw null; } }
         public static System.Numerics.Vector3 UnitY { get { throw null; } }
         public static System.Numerics.Vector3 UnitZ { get { throw null; } }
+        public float this[int index] { get { throw null; } set { throw null; } }
         public static System.Numerics.Vector3 Zero { get { throw null; } }
         public static System.Numerics.Vector3 Abs(System.Numerics.Vector3 value) { throw null; }
         public static System.Numerics.Vector3 Add(System.Numerics.Vector3 left, System.Numerics.Vector3 right) { throw null; }
@@ -437,6 +442,7 @@ public partial struct Vector4 : System.IEquatable<System.Numerics.Vector4>, Syst
         public static System.Numerics.Vector4 UnitX { get { throw null; } }
         public static System.Numerics.Vector4 UnitY { get { throw null; } }
         public static System.Numerics.Vector4 UnitZ { get { throw null; } }
+        public float this[int index] { get { throw null; } set { throw null; } }
         public static System.Numerics.Vector4 Zero { get { throw null; } }
         public static System.Numerics.Vector4 Abs(System.Numerics.Vector4 value) { throw null; }
         public static System.Numerics.Vector4 Add(System.Numerics.Vector4 left, System.Numerics.Vector4 right) { throw null; }

src/libraries/System.Numerics.Vectors/tests/Matrix3x2Tests.cs

@@ -6,7 +6,7 @@
 
 namespace System.Numerics.Tests
 {
-    public class Matrix3x2Tests
+    public sealed class Matrix3x2Tests
     {
         static Matrix3x2 GenerateIncrementalMatrixNumber(float value = 0.0f)
         {
@@ -27,6 +27,47 @@ static Matrix3x2 GenerateTestMatrix()
             return m;
         }
 
+        [Theory]
+        [InlineData(0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f)]
+        [InlineData(1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f)]
+        [InlineData(3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f, 3.1434343f, 1.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f, 1.0000001f, 0.0000001f)]
+        public void Matrix3x2IndexerGetTest(float m11, float m12, float m21, float m22, float m31, float m32)
+        {
+            var matrix = new Matrix3x2(m11, m12, m21, m22, m31, m32);
+
+            Assert.Equal(m11, matrix[0, 0]);
+            Assert.Equal(m12, matrix[0, 1]);
+            Assert.Equal(m21, matrix[1, 0]);
+            Assert.Equal(m22, matrix[1, 1]);
+            Assert.Equal(m31, matrix[2, 0]);
+            Assert.Equal(m32, matrix[2, 1]);
+        }
+
+        [Theory]
+        [InlineData(0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f)]
+        [InlineData(1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f)]
+        [InlineData(3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f, 3.1434343f, 1.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f, 1.0000001f, 0.0000001f)]
+        public void Matrix3x2IndexerSetTest(float m11, float m12, float m21, float m22, float m31, float m32)
+        {
+            var matrix = new Matrix3x2(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+
+            matrix[0, 0] = m11;
+            matrix[0, 1] = m12;
+            matrix[1, 0] = m21;
+            matrix[1, 1] = m22;
+            matrix[2, 0] = m31;
+            matrix[2, 1] = m32;
+
+            Assert.Equal(m11, matrix[0, 0]);
+            Assert.Equal(m12, matrix[0, 1]);
+            Assert.Equal(m21, matrix[1, 0]);
+            Assert.Equal(m22, matrix[1, 1]);
+            Assert.Equal(m31, matrix[2, 0]);
+            Assert.Equal(m32, matrix[2, 1]);
+        }
+
         // A test for Identity
         [Fact]
         public void Matrix3x2IdentityTest()

src/libraries/System.Numerics.Vectors/tests/Matrix4x4Tests.cs

@@ -7,7 +7,7 @@
 
 namespace System.Numerics.Tests
 {
-    public class Matrix4x4Tests
+    public sealed class Matrix4x4Tests
     {
         static Matrix4x4 GenerateIncrementalMatrixNumber(float value = 0.0f)
         {
@@ -41,6 +41,86 @@ static Matrix4x4 GenerateTestMatrix()
             return m;
         }
 
+        [Theory]
+        [InlineData(0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f)]
+        [InlineData(1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f)]
+        [InlineData(3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f, 3.1434343f, 1.1234123f, 3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f, 3.1434343f, 1.1234123f, 3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f, 1.0000001f, 0.0000001f, 1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f, 1.0000001f, 0.0000001f, 1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f)]
+        public void Matrix4x4IndexerGetTest(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
+        {
+            var matrix = new Matrix4x4(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+
+            Assert.Equal(m11, matrix[0, 0]);
+            Assert.Equal(m12, matrix[0, 1]);
+            Assert.Equal(m13, matrix[0, 2]);
+            Assert.Equal(m14, matrix[0, 3]);
+
+            Assert.Equal(m21, matrix[1, 0]);
+            Assert.Equal(m22, matrix[1, 1]);
+            Assert.Equal(m23, matrix[1, 2]);
+            Assert.Equal(m24, matrix[1, 3]);
+
+            Assert.Equal(m31, matrix[2, 0]);
+            Assert.Equal(m32, matrix[2, 1]);
+            Assert.Equal(m33, matrix[2, 2]);
+            Assert.Equal(m34, matrix[2, 3]);
+
+            Assert.Equal(m41, matrix[3, 0]);
+            Assert.Equal(m42, matrix[3, 1]);
+            Assert.Equal(m43, matrix[3, 2]);
+            Assert.Equal(m44, matrix[3, 3]);
+        }
+
+        [Theory]
+        [InlineData(0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f)]
+        [InlineData(1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f)]
+        [InlineData(3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f, 3.1434343f, 1.1234123f, 3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f, 3.1434343f, 1.1234123f, 3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f, 1.0000001f, 0.0000001f, 1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f, 1.0000001f, 0.0000001f, 1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f)]
+        public void Matrix4x4IndexerSetTest(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
+        {
+            var matrix = new Matrix4x4(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+
+            matrix[0, 0] = m11;
+            matrix[0, 1] = m12;
+            matrix[0, 2] = m13;
+            matrix[0, 3] = m14;
+
+            matrix[1, 0] = m21;
+            matrix[1, 1] = m22;
+            matrix[1, 2] = m23;
+            matrix[1, 3] = m24;
+
+            matrix[2, 0] = m31;
+            matrix[2, 1] = m32;
+            matrix[2, 2] = m33;
+            matrix[2, 3] = m34;
+
+            matrix[3, 0] = m41;
+            matrix[3, 1] = m42;
+            matrix[3, 2] = m43;
+            matrix[3, 3] = m44;
+
+            Assert.Equal(m11, matrix[0, 0]);
+            Assert.Equal(m12, matrix[0, 1]);
+            Assert.Equal(m13, matrix[0, 2]);
+            Assert.Equal(m14, matrix[0, 3]);
+
+            Assert.Equal(m21, matrix[1, 0]);
+            Assert.Equal(m22, matrix[1, 1]);
+            Assert.Equal(m23, matrix[1, 2]);
+            Assert.Equal(m24, matrix[1, 3]);
+
+            Assert.Equal(m31, matrix[2, 0]);
+            Assert.Equal(m32, matrix[2, 1]);
+            Assert.Equal(m33, matrix[2, 2]);
+            Assert.Equal(m34, matrix[2, 3]);
+
+            Assert.Equal(m41, matrix[3, 0]);
+            Assert.Equal(m42, matrix[3, 1]);
+            Assert.Equal(m43, matrix[3, 2]);
+            Assert.Equal(m44, matrix[3, 3]);
+        }
+
         // A test for Identity
         [Fact]
         public void Matrix4x4IdentityTest()

src/libraries/System.Numerics.Vectors/tests/QuaternionTests.cs

@@ -7,7 +7,7 @@
 
 namespace System.Numerics.Tests
 {
-    public class QuaternionTests
+    public sealed class QuaternionTests
     {
         // A test for Dot (Quaternion, Quaternion)
         [Fact]
@@ -23,6 +23,41 @@ public void QuaternionDotTest()
             Assert.True(MathHelper.Equal(expected, actual), $"Quaternion.Dot did not return the expected value: expected {expected} actual {actual}");
         }
 
+        [Theory]
+        [InlineData(0.0f, 1.0f, 0.0f, 1.0f)]
+        [InlineData(1.0f, 0.0f, 1.0f, 0.0f)]
+        [InlineData(3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f)]
+        public void QuaternionIndexerGetTest(float x, float y, float z, float w)
+        {
+            var quaternion = new Quaternion(x, y, z, w);
+
+            Assert.Equal(x, quaternion[0]);
+            Assert.Equal(y, quaternion[1]);
+            Assert.Equal(z, quaternion[2]);
+            Assert.Equal(w, quaternion[3]);
+        }
+
+        [Theory]
+        [InlineData(0.0f, 1.0f, 0.0f, 1.0f)]
+        [InlineData(1.0f, 0.0f, 1.0f, 0.0f)]
+        [InlineData(3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f)]
+        public void QuaternionIndexerSetTest(float x, float y, float z, float w)
+        {
+            var quaternion = new Quaternion(0.0f, 0.0f, 0.0f, 0.0f);
+
+            quaternion[0] = x;
+            quaternion[1] = y;
+            quaternion[2] = z;
+            quaternion[3] = w;
+
+            Assert.Equal(x, quaternion[0]);
+            Assert.Equal(y, quaternion[1]);
+            Assert.Equal(z, quaternion[2]);
+            Assert.Equal(w, quaternion[3]);
+        }
+
         // A test for Length ()
         [Fact]
         public void QuaternionLengthTest()

src/libraries/System.Numerics.Vectors/tests/Vector2Tests.cs

@@ -7,7 +7,7 @@
 
 namespace System.Numerics.Tests
 {
-    public class Vector2Tests
+    public sealed class Vector2Tests
     {
         [Fact]
         public void Vector2MarshalSizeTest()
@@ -16,6 +16,35 @@ public void Vector2MarshalSizeTest()
             Assert.Equal(8, Marshal.SizeOf<Vector2>(new Vector2()));
         }
 
+        [Theory]
+        [InlineData(0.0f, 1.0f)]
+        [InlineData(1.0f, 0.0f)]
+        [InlineData(3.1434343f, 1.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f)]
+        public void Vector2IndexerGetTest(float x, float y)
+        {
+            var vector = new Vector2(x, y);
+
+            Assert.Equal(x, vector[0]);
+            Assert.Equal(y, vector[1]);
+        }
+
+        [Theory]
+        [InlineData(0.0f, 1.0f)]
+        [InlineData(1.0f, 0.0f)]
+        [InlineData(3.1434343f, 1.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f)]
+        public void Vector2IndexerSetTest(float x, float y)
+        {
+            var vector = new Vector2(0.0f, 0.0f);
+
+            vector[0] = x;
+            vector[1] = y;
+
+            Assert.Equal(x, vector[0]);
+            Assert.Equal(y, vector[1]);
+        }
+
         [Fact]
         public void Vector2CopyToTest()
         {

src/libraries/System.Numerics.Vectors/tests/Vector3Tests.cs

@@ -7,7 +7,7 @@
 
 namespace System.Numerics.Tests
 {
-    public class Vector3Tests
+    public sealed class Vector3Tests
     {
         [Fact]
         public void Vector3MarshalSizeTest()
@@ -16,6 +16,38 @@ public void Vector3MarshalSizeTest()
             Assert.Equal(12, Marshal.SizeOf<Vector3>(new Vector3()));
         }
 
+        [Theory]
+        [InlineData(0.0f, 1.0f, 0.0f)]
+        [InlineData(1.0f, 0.0f, 1.0f)]
+        [InlineData(3.1434343f, 1.1234123f, 0.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f, 2.0000001f)]
+        public void Vector3IndexerGetTest(float x, float y, float z)
+        {
+            var vector = new Vector3(x, y, z);
+
+            Assert.Equal(x, vector[0]);
+            Assert.Equal(y, vector[1]);
+            Assert.Equal(z, vector[2]);
+        }
+
+        [Theory]
+        [InlineData(0.0f, 1.0f, 0.0f)]
+        [InlineData(1.0f, 0.0f, 1.0f)]
+        [InlineData(3.1434343f, 1.1234123f, 0.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f, 2.0000001f)]
+        public void Vector3IndexerSetTest(float x, float y, float z)
+        {
+            var vector = new Vector3(0.0f, 0.0f, 0.0f);
+
+            vector[0] = x;
+            vector[1] = y;
+            vector[2] = z;
+
+            Assert.Equal(x, vector[0]);
+            Assert.Equal(y, vector[1]);
+            Assert.Equal(z, vector[2]);
+        }
+
         [Fact]
         public void Vector3CopyToTest()
         {

src/libraries/System.Numerics.Vectors/tests/Vector4Tests.cs

@@ -7,7 +7,7 @@
 
 namespace System.Numerics.Tests
 {
-    public class Vector4Tests
+    public sealed class Vector4Tests
     {
         [Fact]
         public void Vector4MarshalSizeTest()
@@ -16,6 +16,41 @@ public void Vector4MarshalSizeTest()
             Assert.Equal(16, Marshal.SizeOf<Vector4>(new Vector4()));
         }
 
+        [Theory]
+        [InlineData(0.0f, 1.0f, 0.0f, 1.0f)]
+        [InlineData(1.0f, 0.0f, 1.0f, 0.0f)]
+        [InlineData(3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f)]
+        public void Vector4IndexerGetTest(float x, float y, float z, float w)
+        {
+            var vector = new Vector4(x, y, z, w);
+
+            Assert.Equal(x, vector[0]);
+            Assert.Equal(y, vector[1]);
+            Assert.Equal(z, vector[2]);
+            Assert.Equal(w, vector[3]);
+        }
+
+        [Theory]
+        [InlineData(0.0f, 1.0f, 0.0f, 1.0f)]
+        [InlineData(1.0f, 0.0f, 1.0f, 0.0f)]
+        [InlineData(3.1434343f, 1.1234123f, 0.1234123f, -0.1234123f)]
+        [InlineData(1.0000001f, 0.0000001f, 2.0000001f, 0.0000002f)]
+        public void Vector4IndexerSetTest(float x, float y, float z, float w)
+        {
+            var vector = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+
+            vector[0] = x;
+            vector[1] = y;
+            vector[2] = z;
+            vector[3] = w;
+
+            Assert.Equal(x, vector[0]);
+            Assert.Equal(y, vector[1]);
+            Assert.Equal(z, vector[2]);
+            Assert.Equal(w, vector[3]);
+        }
+
         [Fact]
         public void Vector4CopyToTest()
         {