Adding the Vector512 and Vector512<T> types

src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs

@@ -198,15 +198,10 @@ public T this[int index]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector128<T> operator /(Vector128<T> left, T right)
         {
-            Unsafe.SkipInit(out Vector128<T> result);
-
-            for (int index = 0; index < Count; index++)
-            {
-                T value = Scalar<T>.Divide(left.GetElementUnsafe(index), right);
-                result.SetElementUnsafe(index, value);
-            }
-
-            return result;
+            return Vector128.Create(
+                left._lower / right,
+                left._upper / right
+            );
         }
 
         /// <summary>Compares two vectors to determine if all elements are equal.</summary>
@@ -258,15 +253,10 @@ public T this[int index]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector128<T> operator <<(Vector128<T> value, int shiftCount)
         {
-            Unsafe.SkipInit(out Vector128<T> result);
-
-            for (int index = 0; index < Count; index++)
-            {
-                T element = Scalar<T>.ShiftLeft(value.GetElementUnsafe(index), shiftCount);
-                result.SetElementUnsafe(index, element);
-            }
-
-            return result;
+            return Vector128.Create(
+                value._lower << shiftCount,
+                value._upper << shiftCount
+            );
         }
 
         /// <summary>Multiplies two vectors to compute their element-wise product.</summary>
@@ -330,15 +320,10 @@ public T this[int index]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector128<T> operator >>(Vector128<T> value, int shiftCount)
         {
-            Unsafe.SkipInit(out Vector128<T> result);
-
-            for (int index = 0; index < Count; index++)
-            {
-                T element = Scalar<T>.ShiftRightArithmetic(value.GetElementUnsafe(index), shiftCount);
-                result.SetElementUnsafe(index, element);
-            }
-
-            return result;
+            return Vector128.Create(
+                value._lower >> shiftCount,
+                value._upper >> shiftCount
+            );
         }
 
         /// <summary>Subtracts two vectors to compute their difference.</summary>
@@ -390,15 +375,10 @@ public static Vector128<T> operator >>(Vector128<T> value, int shiftCount)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector128<T> operator >>>(Vector128<T> value, int shiftCount)
         {
-            Unsafe.SkipInit(out Vector128<T> result);
-
-            for (int index = 0; index < Count; index++)
-            {
-                T element = Scalar<T>.ShiftRightLogical(value.GetElementUnsafe(index), shiftCount);
-                result.SetElementUnsafe(index, element);
-            }
-
-            return result;
+            return Vector128.Create(
+                value._lower >>> shiftCount,
+                value._upper >>> shiftCount
+            );
         }
 
         /// <summary>Determines whether the specified object is equal to the current instance.</summary>

src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs

@@ -2833,7 +2833,7 @@ public static bool TryCopyTo<T>(this Vector256<T> vector, Span<T> destination)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static (Vector256<ulong> Lower, Vector256<ulong> Upper) Widen(Vector256<uint> source) => (WidenLower(source), WidenUpper(source));
 
-        /// <summary>Widens the lower half of a <see cref="Vector128{Byte}" /> into a <see cref="Vector128{UInt16} " />.</summary>
+        /// <summary>Widens the lower half of a <see cref="Vector256{Byte}" /> into a <see cref="Vector256{UInt16} " />.</summary>
         /// <param name="source">The vector whose elements are to be widened.</param>
         /// <returns>A vector that contain the widened lower half of <paramref name="source" />.</returns>
         [Intrinsic]
@@ -2849,7 +2849,7 @@ public static Vector256<ushort> WidenLower(Vector256<byte> source)
             );
         }
 
-        /// <summary>Widens the lower half of a <see cref="Vector128{Int16}" /> into a <see cref="Vector128{Int32} " />.</summary>
+        /// <summary>Widens the lower half of a <see cref="Vector256{Int16}" /> into a <see cref="Vector256{Int32} " />.</summary>
         /// <param name="source">The vector whose elements are to be widened.</param>
         /// <returns>A vector that contain the widened lower half of <paramref name="source" />.</returns>
         [Intrinsic]
@@ -2864,7 +2864,7 @@ public static Vector256<int> WidenLower(Vector256<short> source)
             );
         }
 
-        /// <summary>Widens the lower half of a <see cref="Vector128{Int32}" /> into a <see cref="Vector128{Int64} " />.</summary>
+        /// <summary>Widens the lower half of a <see cref="Vector256{Int32}" /> into a <see cref="Vector256{Int64} " />.</summary>
         /// <param name="source">The vector whose elements are to be widened.</param>
         /// <returns>A vector that contain the widened lower half of <paramref name="source" />.</returns>
         [Intrinsic]
@@ -2879,7 +2879,7 @@ public static Vector256<long> WidenLower(Vector256<int> source)
             );
         }
 
-        /// <summary>Widens the lower half of a <see cref="Vector128{SByte}" /> into a <see cref="Vector128{Int16} " />.</summary>
+        /// <summary>Widens the lower half of a <see cref="Vector256{SByte}" /> into a <see cref="Vector256{Int16} " />.</summary>
         /// <param name="source">The vector whose elements are to be widened.</param>
         /// <returns>A vector that contain the widened lower half of <paramref name="source" />.</returns>
         [Intrinsic]
@@ -2894,7 +2894,7 @@ public static Vector256<short> WidenLower(Vector256<sbyte> source)
                 Vector128.WidenUpper(lower)
             );
         }
-        /// <summary>Widens the lower half of a <see cref="Vector128{Single}" /> into a <see cref="Vector128{Double} " />.</summary>
+        /// <summary>Widens the lower half of a <see cref="Vector256{Single}" /> into a <see cref="Vector256{Double} " />.</summary>
         /// <param name="source">The vector whose elements are to be widened.</param>
         /// <returns>A vector that contain the widened lower half of <paramref name="source" />.</returns>
         [Intrinsic]
@@ -2909,7 +2909,7 @@ public static Vector256<double> WidenLower(Vector256<float> source)
             );
         }
 
-        /// <summary>Widens the lower half of a <see cref="Vector128{UInt16}" /> into a <see cref="Vector128{UInt32} " />.</summary>
+        /// <summary>Widens the lower half of a <see cref="Vector256{UInt16}" /> into a <see cref="Vector256{UInt32} " />.</summary>
         /// <param name="source">The vector whose elements are to be widened.</param>
         /// <returns>A vector that contain the widened lower half of <paramref name="source" />.</returns>
         [Intrinsic]

src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs

@@ -4,7 +4,6 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
-using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
@@ -197,15 +196,10 @@ public T this[int index]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector256<T> operator /(Vector256<T> left, T right)
         {
-            Unsafe.SkipInit(out Vector256<T> result);
-
-            for (int index = 0; index < Count; index++)
-            {
-                T value = Scalar<T>.Divide(left.GetElementUnsafe(index), right);
-                result.SetElementUnsafe(index, value);
-            }
-
-            return result;
+            return Vector256.Create(
+                left._lower / right,
+                left._upper / right
+            );
         }
 
         /// <summary>Compares two vectors to determine if all elements are equal.</summary>
@@ -257,15 +251,10 @@ public T this[int index]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector256<T> operator <<(Vector256<T> value, int shiftCount)
         {
-            Unsafe.SkipInit(out Vector256<T> result);
-
-            for (int index = 0; index < Count; index++)
-            {
-                T element = Scalar<T>.ShiftLeft(value.GetElementUnsafe(index), shiftCount);
-                result.SetElementUnsafe(index, element);
-            }
-
-            return result;
+            return Vector256.Create(
+                value._lower << shiftCount,
+                value._upper << shiftCount
+            );
         }
 
         /// <summary>Multiplies two vectors to compute their element-wise product.</summary>
@@ -329,15 +318,10 @@ public T this[int index]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector256<T> operator >>(Vector256<T> value, int shiftCount)
         {
-            Unsafe.SkipInit(out Vector256<T> result);
-
-            for (int index = 0; index < Count; index++)
-            {
-                T element = Scalar<T>.ShiftRightArithmetic(value.GetElementUnsafe(index), shiftCount);
-                result.SetElementUnsafe(index, element);
-            }
-
-            return result;
+            return Vector256.Create(
+                value._lower >> shiftCount,
+                value._upper >> shiftCount
+            );
         }
 
         /// <summary>Subtracts two vectors to compute their difference.</summary>
@@ -389,15 +373,10 @@ public static Vector256<T> operator >>(Vector256<T> value, int shiftCount)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Vector256<T> operator >>>(Vector256<T> value, int shiftCount)
         {
-            Unsafe.SkipInit(out Vector256<T> result);
-
-            for (int index = 0; index < Count; index++)
-            {
-                T element = Scalar<T>.ShiftRightLogical(value.GetElementUnsafe(index), shiftCount);
-                result.SetElementUnsafe(index, element);
-            }
-
-            return result;
+            return Vector256.Create(
+                value._lower >>> shiftCount,
+                value._upper >>> shiftCount
+            );
         }
 
         /// <summary>Determines whether the specified object is equal to the current instance.</summary>