diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IIndexOfOperator.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IIndexOfOperator.cs
index 09492ac64eb075..8e2f64f979a852 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IIndexOfOperator.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IIndexOfOperator.cs
@@ -9,124 +9,721 @@ namespace System.Numerics.Tensors
 {
     public static unsafe partial class TensorPrimitives
     {
-        private interface IIndexOfOperator<T>
+        private interface IIndexOfMinMaxOperator<T>
         {
-            static abstract int Invoke(ref T result, T current, int resultIndex, int currentIndex);
-            static abstract void Invoke(ref Vector128<T> result, Vector128<T> current, ref Vector128<T> resultIndex, Vector128<T> currentIndex);
-            static abstract void Invoke(ref Vector256<T> result, Vector256<T> current, ref Vector256<T> resultIndex, Vector256<T> currentIndex);
-            static abstract void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex);
+            static abstract bool IsQuickReturn(T value);
+            static abstract Vector128<T> IsQuickReturn(Vector128<T> value);
+            static abstract Vector256<T> IsQuickReturn(Vector256<T> value);
+            static abstract Vector512<T> IsQuickReturn(Vector512<T> value);
+            static abstract T Aggregate(Vector128<T> value);
+            static abstract T Aggregate(Vector256<T> value);
+            static abstract T Aggregate(Vector512<T> value);
+            /// <summary>Returns true if x precedes y.</summary>
+            static abstract bool Compare(T x, T y);
+            static abstract Vector128<T> Compare(Vector128<T> x, Vector128<T> y);
+            static abstract Vector256<T> Compare(Vector256<T> x, Vector256<T> y);
+            static abstract Vector512<T> Compare(Vector512<T> x, Vector512<T> y);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int IndexOfFinalAggregate<T, TIndexOfOperator>(Vector128<T> result, Vector128<T> resultIndex)
-            where TIndexOfOperator : struct, IIndexOfOperator<T>
+        private static int IndexOfMinMaxCore<T, TOperator>(ReadOnlySpan<T> x)
+            where T : INumber<T> where TOperator : struct, IIndexOfMinMaxOperator<T>
         {
-            Vector128<T> tmpResult;
-            Vector128<T> tmpIndex;
+            if (x.IsEmpty)
+            {
+                return -1;
+            }
+
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count)
+            {
+                return sizeof(T) == 8 ? IndexOfMinMaxVector512Size4Plus<T, TOperator, ulong>(x) :
+                    sizeof(T) == 4 ? IndexOfMinMaxVector512Size4Plus<T, TOperator, uint>(x) :
+                    sizeof(T) == 2 ? IndexOfMinMaxVector512Size2<T, TOperator>(x) :
+                    IndexOfMinMaxVector512Size1<T, TOperator>(x);
+            }
+
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count)
+            {
+                return sizeof(T) == 8 ? IndexOfMinMaxVector256Size4Plus<T, TOperator, ulong>(x) :
+                    sizeof(T) == 4 ? IndexOfMinMaxVector256Size4Plus<T, TOperator, uint>(x) :
+                    sizeof(T) == 2 ? IndexOfMinMaxVector256Size2<T, TOperator>(x) :
+                    IndexOfMinMaxVector256Size1<T, TOperator>(x);
+            }
+
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && x.Length >= Vector128<T>.Count)
+            {
+                return sizeof(T) == 8 ? IndexOfMinMaxVector128Size4Plus<T, TOperator, ulong>(x) :
+                    sizeof(T) == 4 ? IndexOfMinMaxVector128Size4Plus<T, TOperator, uint>(x) :
+                    sizeof(T) == 2 ? IndexOfMinMaxVector128Size2<T, TOperator>(x) :
+                    IndexOfMinMaxVector128Size1<T, TOperator>(x);
+            }
+
+            return IndexOfMinMaxNaive<T, TOperator>(x);
+        }
+
+        private static int IndexOfMinMaxNaive<T, TOperator>(ReadOnlySpan<T> x)
+            where T : INumber<T> where TOperator : struct, IIndexOfMinMaxOperator<T>
+        {
+            T result = x[0];
+            int resultIndex = 0;
+            if (TOperator.IsQuickReturn(result))
+            {
+                return resultIndex;
+            }
+
+            for (int i = 1; i < x.Length; i++)
+            {
+                T current = x[i];
+                if (TOperator.IsQuickReturn(current))
+                {
+                    return i;
+                }
+                if (TOperator.Compare(current, result))
+                {
+                    result = current;
+                    resultIndex = i;
+                }
+            }
+
+            return resultIndex;
+        }
+
+        private static int IndexOfMinMaxVector128Size4Plus<T, TOperator, TInt>(ReadOnlySpan<T> x)
+            where T : INumber<T> where TOperator : struct, IIndexOfMinMaxOperator<T> where TInt : IBinaryInteger<TInt>
+        {
+            Debug.Assert(sizeof(T) == 4 || sizeof(T) == 8);
+            Debug.Assert(typeof(TInt) == typeof(uint) || typeof(TInt) == typeof(ulong));
+            Debug.Assert(sizeof(TInt) == sizeof(T));
+
+            // Initialize result by reading first vector and quick return if possible.
+            Vector128<T> result = Vector128.Create(x);
+            Vector128<T> mask = TOperator.IsQuickReturn(result);
+            if (mask != Vector128<T>.Zero)
+            {
+                return IndexOfFirstMatch(mask);
+            }
+
+            // Initialize indices.
+            Vector128<TInt> indexIncrement = Vector128.Create(TInt.CreateChecked(Vector128<TInt>.Count));
+            Vector128<TInt> resultIndex = Vector128<TInt>.Indices;
+            Vector128<TInt> currentIndex = resultIndex + indexIncrement;
+            ReadOnlySpan<T> span = x.Slice(Vector128<T>.Count);
+
+            while (!span.IsEmpty)
+            {
+                Vector128<T> current;
+                if (span.Length >= Vector128<T>.Count)
+                {
+                    current = Vector128.Create(span);
+                    span = span.Slice(Vector128<T>.Count);
+                }
+                else
+                {
+                    // Process a final back-shifted to cover remaining elements in x in one vector.
+                    int start = x.Length - Vector128<T>.Count;
+                    current = Vector128.Create(x.Slice(start));
+                    currentIndex = Vector128.Create(TInt.CreateChecked(start)) + Vector128<TInt>.Indices;
+                    span = ReadOnlySpan<T>.Empty;
+                }
+
+                // Quick return if possible.
+                mask = TOperator.IsQuickReturn(current);
+                if (mask != Vector128<T>.Zero)
+                {
+                    return int.CreateChecked(currentIndex.ToScalar()) + IndexOfFirstMatch(mask);
+                }
+
+                // Get mask for which lanes that should have result updated.
+                mask = TOperator.Compare(current, result);
+
+                // Update result and indices.
+                result = ElementWiseSelect(mask, current, result);
+                resultIndex = ElementWiseSelect(mask.As<T, TInt>(), currentIndex, resultIndex);
+                currentIndex += indexIncrement;
+            }
+
+            {
+                // Where result does not bitwise-equal the aggregate min/max value; replace indices with uint.MaxValue. Then find the min index.
+                T aggResult = TOperator.Aggregate(result);
+                Vector128<TInt> aggMask = ~Vector128.Equals(result.As<T, TInt>(), Vector128.Create(aggResult).As<T, TInt>());
+                Vector128<TInt> aggIndex = resultIndex | aggMask;
+                return int.CreateChecked(HorizontalAggregate<TInt, MinOperator<TInt>>(aggIndex));
+            }
+        }
+
+        private static int IndexOfMinMaxVector128Size2<T, TOperator>(ReadOnlySpan<T> x)
+            where T : INumber<T> where TOperator : struct, IIndexOfMinMaxOperator<T>
+        {
+            Debug.Assert(sizeof(T) == 2);
+
+            // Initialize result by reading first vector and quick return if possible.
+            Vector128<T> result = Vector128.Create(x);
+            Vector128<T> mask = TOperator.IsQuickReturn(result);
+            if (mask != Vector128<T>.Zero)
+            {
+                return IndexOfFirstMatch(mask);
+            }
+
+            // Initialize indices.
+            Vector128<uint> indexIncrement = Vector128.Create((uint)Vector128<uint>.Count);
+            Vector128<uint> resultIndex1 = Vector128<uint>.Indices;
+            Vector128<uint> resultIndex2 = resultIndex1 + indexIncrement;
+            Vector128<uint> currentIndex = resultIndex2 + indexIncrement;
+            ReadOnlySpan<T> span = x.Slice(Vector128<T>.Count);
+
+            while (!span.IsEmpty)
+            {
+                Vector128<T> current;
+                if (span.Length >= Vector128<T>.Count)
+                {
+                    current = Vector128.Create(span);
+                    span = span.Slice(Vector128<T>.Count);
+                }
+                else
+                {
+                    // Process a final back-shifted to cover remaining elements in x in one vector.
+                    int start = x.Length - Vector128<T>.Count;
+                    current = Vector128.Create(x.Slice(start));
+                    currentIndex = Vector128.Create((uint)start) + Vector128<uint>.Indices;
+                    span = ReadOnlySpan<T>.Empty;
+                }
+
+                // Quick return if possible.
+                mask = TOperator.IsQuickReturn(current);
+                if (mask != Vector128<T>.Zero)
+                {
+                    return (int)currentIndex.ToScalar() + IndexOfFirstMatch(mask);
+                }
+
+                // Get mask for which lanes that should have result updated, also widen it for updating the indices.
+                mask = TOperator.Compare(current, result);
+                (Vector128<int> mask1, Vector128<int> mask2) = Vector128.Widen(mask.AsInt16());
+
+                // Update result and indices.
+                result = ElementWiseSelect(mask, current, result);
+                resultIndex1 = ElementWiseSelect(mask1.AsUInt32(), currentIndex, resultIndex1);
+                currentIndex += indexIncrement;
+                resultIndex2 = ElementWiseSelect(mask2.AsUInt32(), currentIndex, resultIndex2);
+                currentIndex += indexIncrement;
+            }
+
+            {
+                // Where result does not bitwise-equal the aggregate min/max value; replace indices with uint.MaxValue. Then find the min index.
+                T aggResult = TOperator.Aggregate(result);
+                Vector128<short> aggMask = ~Vector128.Equals(result.AsInt16(), Vector128.Create(aggResult).AsInt16());
+
+                (Vector128<int> mask1, Vector128<int> mask2) = Vector128.Widen(aggMask);
+                Vector128<uint> aggIndex = resultIndex1 | mask1.AsUInt32();
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex2 | mask2.AsUInt32());
+
+                return (int)HorizontalAggregate<uint, MinOperator<uint>>(aggIndex);
+            }
+        }
+
+        private static int IndexOfMinMaxVector128Size1<T, TOperator>(ReadOnlySpan<T> x)
+            where T : INumber<T> where TOperator : struct, IIndexOfMinMaxOperator<T>
+        {
+            Debug.Assert(sizeof(T) == 1);
+
+            // Initialize result by reading first vector and quick return if possible.
+            Vector128<T> result = Vector128.Create(x);
+            Vector128<T> mask = TOperator.IsQuickReturn(result);
+            if (mask != Vector128<T>.Zero)
+            {
+                return IndexOfFirstMatch(mask);
+            }
+
+            // Initialize indices.
+            Vector128<uint> indexIncrement = Vector128.Create((uint)Vector128<uint>.Count);
+            Vector128<uint> resultIndex1 = Vector128<uint>.Indices;
+            Vector128<uint> resultIndex2 = resultIndex1 + indexIncrement;
+            Vector128<uint> resultIndex3 = resultIndex2 + indexIncrement;
+            Vector128<uint> resultIndex4 = resultIndex3 + indexIncrement;
+            Vector128<uint> currentIndex = resultIndex4 + indexIncrement;
+            ReadOnlySpan<T> span = x.Slice(Vector128<T>.Count);
+
+            while (!span.IsEmpty)
+            {
+                Vector128<T> current;
+                if (span.Length >= Vector128<T>.Count)
+                {
+                    current = Vector128.Create(span);
+                    span = span.Slice(Vector128<T>.Count);
+                }
+                else
+                {
+                    // Process a final back-shifted to cover remaining elements in x in one vector.
+                    int start = x.Length - Vector128<T>.Count;
+                    current = Vector128.Create(x.Slice(start));
+                    currentIndex = Vector128.Create((uint)start) + Vector128<uint>.Indices;
+                    span = ReadOnlySpan<T>.Empty;
+                }
+
+                // Quick return if possible.
+                mask = TOperator.IsQuickReturn(current);
+                if (mask != Vector128<T>.Zero)
+                {
+                    return (int)currentIndex.ToScalar() + IndexOfFirstMatch(mask);
+                }
+
+                // Get mask for which lanes that should have result updated, also widen it for updating the indices.
+                mask = TOperator.Compare(current, result);
+                (Vector128<short> lowerMask, Vector128<short> upperMask) = Vector128.Widen(mask.AsSByte());
+                (Vector128<int> mask1, Vector128<int> mask2) = Vector128.Widen(lowerMask);
+                (Vector128<int> mask3, Vector128<int> mask4) = Vector128.Widen(upperMask);
+
+                // Update result and indices.
+                result = ElementWiseSelect(mask, current, result);
+                resultIndex1 = ElementWiseSelect(mask1.AsUInt32(), currentIndex, resultIndex1);
+                currentIndex += indexIncrement;
+                resultIndex2 = ElementWiseSelect(mask2.AsUInt32(), currentIndex, resultIndex2);
+                currentIndex += indexIncrement;
+                resultIndex3 = ElementWiseSelect(mask3.AsUInt32(), currentIndex, resultIndex3);
+                currentIndex += indexIncrement;
+                resultIndex4 = ElementWiseSelect(mask4.AsUInt32(), currentIndex, resultIndex4);
+                currentIndex += indexIncrement;
+            }
+
+            {
+                // Where result does not bitwise-equal the aggregate min/max value; replace indices with uint.MaxValue. Then find the min index.
+                T aggResult = TOperator.Aggregate(result);
+                Vector128<sbyte> aggMask = ~Vector128.Equals(result.AsSByte(), Vector128.Create(aggResult).AsSByte());
+
+                (Vector128<short> lowerMask, Vector128<short> upperMask) = Vector128.Widen(aggMask);
+                (Vector128<int> mask1, Vector128<int> mask2) = Vector128.Widen(lowerMask);
+                (Vector128<int> mask3, Vector128<int> mask4) = Vector128.Widen(upperMask);
+                Vector128<uint> aggIndex = resultIndex1 | mask1.AsUInt32();
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex2 | mask2.AsUInt32());
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex3 | mask3.AsUInt32());
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex4 | mask4.AsUInt32());
+
+                return (int)HorizontalAggregate<uint, MinOperator<uint>>(aggIndex);
+            }
+        }
+
+        private static int IndexOfMinMaxVector256Size4Plus<T, TOperator, TInt>(ReadOnlySpan<T> x)
+            where T : INumber<T> where TOperator : struct, IIndexOfMinMaxOperator<T> where TInt : IBinaryInteger<TInt>
+        {
+            Debug.Assert(sizeof(T) == 4 || sizeof(T) == 8);
+            Debug.Assert(typeof(TInt) == typeof(uint) || typeof(TInt) == typeof(ulong));
+            Debug.Assert(sizeof(TInt) == sizeof(T));
+
+            // Initialize result by reading first vector and quick return if possible.
+            Vector256<T> result = Vector256.Create(x);
+            Vector256<T> mask = TOperator.IsQuickReturn(result);
+            if (mask != Vector256<T>.Zero)
+            {
+                return IndexOfFirstMatch(mask);
+            }
+
+            // Initialize indices.
+            Vector256<TInt> indexIncrement = Vector256.Create(TInt.CreateChecked(Vector256<TInt>.Count));
+            Vector256<TInt> resultIndex = Vector256<TInt>.Indices;
+            Vector256<TInt> currentIndex = resultIndex + indexIncrement;
+            ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count);
 
-            if (sizeof(T) == 8)
+            while (!span.IsEmpty)
             {
-                // Compare 0 with 1
-                tmpResult = Vector128.Shuffle(result.AsInt64(), Vector128.Create(1, 0)).As<long, T>();
-                tmpIndex = Vector128.Shuffle(resultIndex.AsInt64(), Vector128.Create(1, 0)).As<long, T>();
-                TIndexOfOperator.Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
+                Vector256<T> current;
+                if (span.Length >= Vector256<T>.Count)
+                {
+                    current = Vector256.Create(span);
+                    span = span.Slice(Vector256<T>.Count);
+                }
+                else
+                {
+                    // Process a final back-shifted to cover remaining elements in x in one vector.
+                    int start = x.Length - Vector256<T>.Count;
+                    current = Vector256.Create(x.Slice(start));
+                    currentIndex = Vector256.Create(TInt.CreateChecked(start)) + Vector256<TInt>.Indices;
+                    span = ReadOnlySpan<T>.Empty;
+                }
+
+                // Quick return if possible.
+                mask = TOperator.IsQuickReturn(current);
+                if (mask != Vector256<T>.Zero)
+                {
+                    return int.CreateChecked(currentIndex.ToScalar()) + IndexOfFirstMatch(mask);
+                }
 
-                // Return 0
-                return (int)resultIndex.As<T, long>().ToScalar();
+                // Get mask for which lanes that should have result updated.
+                mask = TOperator.Compare(current, result);
+
+                // Update result and indices.
+                result = ElementWiseSelect(mask, current, result);
+                resultIndex = ElementWiseSelect(mask.As<T, TInt>(), currentIndex, resultIndex);
+                currentIndex += indexIncrement;
             }
 
-            if (sizeof(T) == 4)
             {
-                // Compare 0,1 with 2,3
-                tmpResult = Vector128.Shuffle(result.AsInt32(), Vector128.Create(2, 3, 0, 1)).As<int, T>();
-                tmpIndex = Vector128.Shuffle(resultIndex.AsInt32(), Vector128.Create(2, 3, 0, 1)).As<int, T>();
-                TIndexOfOperator.Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
+                // Where result does not bitwise-equal the aggregate min/max value; replace indices with uint.MaxValue. Then find the min index.
+                T aggResult = TOperator.Aggregate(result);
+                Vector256<TInt> aggMask = ~Vector256.Equals(result.As<T, TInt>(), Vector256.Create(aggResult).As<T, TInt>());
+                Vector256<TInt> aggIndex = resultIndex | aggMask;
+                return int.CreateChecked(HorizontalAggregate<TInt, MinOperator<TInt>>(aggIndex));
+            }
+        }
 
-                // Compare 0 with 1
-                tmpResult = Vector128.Shuffle(result.AsInt32(), Vector128.Create(1, 0, 3, 2)).As<int, T>();
-                tmpIndex = Vector128.Shuffle(resultIndex.AsInt32(), Vector128.Create(1, 0, 3, 2)).As<int, T>();
-                TIndexOfOperator.Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
+        private static int IndexOfMinMaxVector256Size2<T, TOperator>(ReadOnlySpan<T> x)
+            where T : INumber<T> where TOperator : struct, IIndexOfMinMaxOperator<T>
+        {
+            Debug.Assert(sizeof(T) == 2);
 
-                // Return 0
-                return resultIndex.As<T, int>().ToScalar();
+            // Initialize result by reading first vector and quick return if possible.
+            Vector256<T> result = Vector256.Create(x);
+            Vector256<T> mask = TOperator.IsQuickReturn(result);
+            if (mask != Vector256<T>.Zero)
+            {
+                return IndexOfFirstMatch(mask);
             }
 
-            if (sizeof(T) == 2)
+            // Initialize indices.
+            Vector256<uint> indexIncrement = Vector256.Create((uint)Vector256<uint>.Count);
+            Vector256<uint> resultIndex1 = Vector256<uint>.Indices;
+            Vector256<uint> resultIndex2 = resultIndex1 + indexIncrement;
+            Vector256<uint> currentIndex = resultIndex2 + indexIncrement;
+            ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count);
+
+            while (!span.IsEmpty)
             {
-                // Compare 0,1,2,3 with 4,5,6,7
-                tmpResult = Vector128.Shuffle(result.AsInt16(), Vector128.Create(4, 5, 6, 7, 0, 1, 2, 3)).As<short, T>();
-                tmpIndex = Vector128.Shuffle(resultIndex.AsInt16(), Vector128.Create(4, 5, 6, 7, 0, 1, 2, 3)).As<short, T>();
-                TIndexOfOperator.Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
+                Vector256<T> current;
+                if (span.Length >= Vector256<T>.Count)
+                {
+                    current = Vector256.Create(span);
+                    span = span.Slice(Vector256<T>.Count);
+                }
+                else
+                {
+                    // Process a final back-shifted to cover remaining elements in x in one vector.
+                    int start = x.Length - Vector256<T>.Count;
+                    current = Vector256.Create(x.Slice(start));
+                    currentIndex = Vector256.Create((uint)start) + Vector256<uint>.Indices;
+                    span = ReadOnlySpan<T>.Empty;
+                }
 
-                // Compare 0,1 with 2,3
-                tmpResult = Vector128.Shuffle(result.AsInt16(), Vector128.Create(2, 3, 0, 1, 4, 5, 6, 7)).As<short, T>();
-                tmpIndex = Vector128.Shuffle(resultIndex.AsInt16(), Vector128.Create(2, 3, 0, 1, 4, 5, 6, 7)).As<short, T>();
-                TIndexOfOperator.Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
+                // Quick return if possible.
+                mask = TOperator.IsQuickReturn(current);
+                if (mask != Vector256<T>.Zero)
+                {
+                    return (int)currentIndex.ToScalar() + IndexOfFirstMatch(mask);
+                }
 
-                // Compare 0 with 1
-                tmpResult = Vector128.Shuffle(result.AsInt16(), Vector128.Create(1, 0, 2, 3, 4, 5, 6, 7)).As<short, T>();
-                tmpIndex = Vector128.Shuffle(resultIndex.AsInt16(), Vector128.Create(1, 0, 2, 3, 4, 5, 6, 7)).As<short, T>();
-                TIndexOfOperator.Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
+                // Get mask for which lanes that should have result updated, also widen it for updating the indices.
+                mask = TOperator.Compare(current, result);
+                (Vector256<int> mask1, Vector256<int> mask2) = Vector256.Widen(mask.AsInt16());
 
-                // Return 0
-                return resultIndex.As<T, short>().ToScalar();
+                // Update result and indices.
+                result = ElementWiseSelect(mask, current, result);
+                resultIndex1 = ElementWiseSelect(mask1.AsUInt32(), currentIndex, resultIndex1);
+                currentIndex += indexIncrement;
+                resultIndex2 = ElementWiseSelect(mask2.AsUInt32(), currentIndex, resultIndex2);
+                currentIndex += indexIncrement;
             }
 
+            {
+                // Where result does not bitwise-equal the aggregate min/max value; replace indices with uint.MaxValue. Then find the min index.
+                T aggResult = TOperator.Aggregate(result);
+                Vector256<short> aggMask = ~Vector256.Equals(result.AsInt16(), Vector256.Create(aggResult).AsInt16());
+
+                (Vector256<int> mask1, Vector256<int> mask2) = Vector256.Widen(aggMask);
+                Vector256<uint> aggIndex = resultIndex1 | mask1.AsUInt32();
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex2 | mask2.AsUInt32());
+
+                return (int)HorizontalAggregate<uint, MinOperator<uint>>(aggIndex);
+            }
+        }
+
+        private static int IndexOfMinMaxVector256Size1<T, TOperator>(ReadOnlySpan<T> x)
+            where T : INumber<T> where TOperator : struct, IIndexOfMinMaxOperator<T>
+        {
             Debug.Assert(sizeof(T) == 1);
+
+            // Initialize result by reading first vector and quick return if possible.
+            Vector256<T> result = Vector256.Create(x);
+            Vector256<T> mask = TOperator.IsQuickReturn(result);
+            if (mask != Vector256<T>.Zero)
             {
-                // Compare 0,1,2,3,4,5,6,7 with 8,9,10,11,12,13,14,15
-                tmpResult = Vector128.Shuffle(result.AsByte(), Vector128.Create((byte)8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7)).As<byte, T>();
-                tmpIndex = Vector128.Shuffle(resultIndex.AsByte(), Vector128.Create((byte)8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7)).As<byte, T>();
-                TIndexOfOperator.Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
+                return IndexOfFirstMatch(mask);
+            }
+
+            // Initialize indices.
+            Vector256<uint> indexIncrement = Vector256.Create((uint)Vector256<uint>.Count);
+            Vector256<uint> resultIndex1 = Vector256<uint>.Indices;
+            Vector256<uint> resultIndex2 = resultIndex1 + indexIncrement;
+            Vector256<uint> resultIndex3 = resultIndex2 + indexIncrement;
+            Vector256<uint> resultIndex4 = resultIndex3 + indexIncrement;
+            Vector256<uint> currentIndex = resultIndex4 + indexIncrement;
+            ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count);
+
+            while (!span.IsEmpty)
+            {
+                Vector256<T> current;
+                if (span.Length >= Vector256<T>.Count)
+                {
+                    current = Vector256.Create(span);
+                    span = span.Slice(Vector256<T>.Count);
+                }
+                else
+                {
+                    // Process a final back-shifted to cover remaining elements in x in one vector.
+                    int start = x.Length - Vector256<T>.Count;
+                    current = Vector256.Create(x.Slice(start));
+                    currentIndex = Vector256.Create((uint)start) + Vector256<uint>.Indices;
+                    span = ReadOnlySpan<T>.Empty;
+                }
+
+                // Quick return if possible.
+                mask = TOperator.IsQuickReturn(current);
+                if (mask != Vector256<T>.Zero)
+                {
+                    return (int)currentIndex.ToScalar() + IndexOfFirstMatch(mask);
+                }
+
+                // Get mask for which lanes that should have result updated, also widen it for updating the indices.
+                mask = TOperator.Compare(current, result);
+                (Vector256<short> lowerMask, Vector256<short> upperMask) = Vector256.Widen(mask.AsSByte());
+                (Vector256<int> mask1, Vector256<int> mask2) = Vector256.Widen(lowerMask);
+                (Vector256<int> mask3, Vector256<int> mask4) = Vector256.Widen(upperMask);
 
-                // Compare 0,1,2,3 with 4,5,6,7
-                tmpResult = Vector128.Shuffle(result.AsByte(), Vector128.Create((byte)4, 5, 6, 7, 0, 1, 2, 3, 8, 9, 10, 11, 12, 13, 14, 15)).As<byte, T>();
-                tmpIndex = Vector128.Shuffle(resultIndex.AsByte(), Vector128.Create((byte)4, 5, 6, 7, 0, 1, 2, 3, 8, 9, 10, 11, 12, 13, 14, 15)).As<byte, T>();
-                TIndexOfOperator.Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
+                // Update result and indices.
+                result = ElementWiseSelect(mask, current, result);
+                resultIndex1 = ElementWiseSelect(mask1.AsUInt32(), currentIndex, resultIndex1);
+                currentIndex += indexIncrement;
+                resultIndex2 = ElementWiseSelect(mask2.AsUInt32(), currentIndex, resultIndex2);
+                currentIndex += indexIncrement;
+                resultIndex3 = ElementWiseSelect(mask3.AsUInt32(), currentIndex, resultIndex3);
+                currentIndex += indexIncrement;
+                resultIndex4 = ElementWiseSelect(mask4.AsUInt32(), currentIndex, resultIndex4);
+                currentIndex += indexIncrement;
+            }
 
-                // Compare 0,1 with 2,3
-                tmpResult = Vector128.Shuffle(result.AsByte(), Vector128.Create((byte)2, 3, 0, 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)).As<byte, T>();
-                tmpIndex = Vector128.Shuffle(resultIndex.AsByte(), Vector128.Create((byte)2, 3, 0, 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)).As<byte, T>();
-                TIndexOfOperator.Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
+            {
+                // Where result does not bitwise-equal the aggregate min/max value; replace indices with uint.MaxValue. Then find the min index.
+                T aggResult = TOperator.Aggregate(result);
+                Vector256<sbyte> aggMask = ~Vector256.Equals(result.AsSByte(), Vector256.Create(aggResult).AsSByte());
 
-                // Compare 0 with 1
-                tmpResult = Vector128.Shuffle(result.AsByte(), Vector128.Create((byte)1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)).As<byte, T>();
-                tmpIndex = Vector128.Shuffle(resultIndex.AsByte(), Vector128.Create((byte)1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)).As<byte, T>();
-                TIndexOfOperator.Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
+                (Vector256<short> lowerMask, Vector256<short> upperMask) = Vector256.Widen(aggMask);
+                (Vector256<int> mask1, Vector256<int> mask2) = Vector256.Widen(lowerMask);
+                (Vector256<int> mask3, Vector256<int> mask4) = Vector256.Widen(upperMask);
+                Vector256<uint> aggIndex = resultIndex1 | mask1.AsUInt32();
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex2 | mask2.AsUInt32());
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex3 | mask3.AsUInt32());
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex4 | mask4.AsUInt32());
 
-                // Return 0
-                return resultIndex.As<T, byte>().ToScalar();
+                return (int)HorizontalAggregate<uint, MinOperator<uint>>(aggIndex);
             }
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int IndexOfFinalAggregate<T, TIndexOfOperator>(Vector256<T> result, Vector256<T> resultIndex)
-            where TIndexOfOperator : struct, IIndexOfOperator<T>
+        private static int IndexOfMinMaxVector512Size4Plus<T, TOperator, TInt>(ReadOnlySpan<T> x)
+            where T : INumber<T> where TOperator : struct, IIndexOfMinMaxOperator<T> where TInt : IBinaryInteger<TInt>
         {
-            // Min the upper/lower halves of the Vector256
-            Vector128<T> resultLower = result.GetLower();
-            Vector128<T> indexLower = resultIndex.GetLower();
+            Debug.Assert(sizeof(T) == 4 || sizeof(T) == 8);
+            Debug.Assert(typeof(TInt) == typeof(uint) || typeof(TInt) == typeof(ulong));
+            Debug.Assert(sizeof(TInt) == sizeof(T));
+
+            // Initialize result by reading first vector and quick return if possible.
+            Vector512<T> result = Vector512.Create(x);
+            Vector512<T> mask = TOperator.IsQuickReturn(result);
+            if (mask != Vector512<T>.Zero)
+            {
+                return IndexOfFirstMatch(mask);
+            }
+
+            // Initialize indices.
+            Vector512<TInt> indexIncrement = Vector512.Create(TInt.CreateChecked(Vector512<TInt>.Count));
+            Vector512<TInt> resultIndex = Vector512<TInt>.Indices;
+            Vector512<TInt> currentIndex = resultIndex + indexIncrement;
+            ReadOnlySpan<T> span = x.Slice(Vector512<T>.Count);
+
+            while (!span.IsEmpty)
+            {
+                Vector512<T> current;
+                if (span.Length >= Vector512<T>.Count)
+                {
+                    current = Vector512.Create(span);
+                    span = span.Slice(Vector512<T>.Count);
+                }
+                else
+                {
+                    // Process a final back-shifted to cover remaining elements in x in one vector.
+                    int start = x.Length - Vector512<T>.Count;
+                    current = Vector512.Create(x.Slice(start));
+                    currentIndex = Vector512.Create(TInt.CreateChecked(start)) + Vector512<TInt>.Indices;
+                    span = ReadOnlySpan<T>.Empty;
+                }
+
+                // Quick return if possible.
+                mask = TOperator.IsQuickReturn(current);
+                if (mask != Vector512<T>.Zero)
+                {
+                    return int.CreateChecked(currentIndex.ToScalar()) + IndexOfFirstMatch(mask);
+                }
 
-            TIndexOfOperator.Invoke(ref resultLower, result.GetUpper(), ref indexLower, resultIndex.GetUpper());
-            return IndexOfFinalAggregate<T, TIndexOfOperator>(resultLower, indexLower);
+                // Get mask for which lanes that should have result updated.
+                mask = TOperator.Compare(current, result);
+
+                // Update result and indices.
+                result = ElementWiseSelect(mask, current, result);
+                resultIndex = ElementWiseSelect(mask.As<T, TInt>(), currentIndex, resultIndex);
+                currentIndex += indexIncrement;
+            }
+
+            {
+                // Where result does not bitwise-equal the aggregate min/max value; replace indices with uint.MaxValue. Then find the min index.
+                T aggResult = TOperator.Aggregate(result);
+                Vector512<TInt> aggMask = ~Vector512.Equals(result.As<T, TInt>(), Vector512.Create(aggResult).As<T, TInt>());
+                Vector512<TInt> aggIndex = resultIndex | aggMask;
+                return int.CreateChecked(HorizontalAggregate<TInt, MinOperator<TInt>>(aggIndex));
+            }
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static int IndexOfFinalAggregate<T, TIndexOfOperator>(Vector512<T> result, Vector512<T> resultIndex)
-            where TIndexOfOperator : struct, IIndexOfOperator<T>
+        private static int IndexOfMinMaxVector512Size2<T, TOperator>(ReadOnlySpan<T> x)
+            where T : INumber<T> where TOperator : struct, IIndexOfMinMaxOperator<T>
         {
-            Vector256<T> resultLower = result.GetLower();
-            Vector256<T> indexLower = resultIndex.GetLower();
+            Debug.Assert(sizeof(T) == 2);
 
-            TIndexOfOperator.Invoke(ref resultLower, result.GetUpper(), ref indexLower, resultIndex.GetUpper());
-            return IndexOfFinalAggregate<T, TIndexOfOperator>(resultLower, indexLower);
+            // Initialize result by reading first vector and quick return if possible.
+            Vector512<T> result = Vector512.Create(x);
+            Vector512<T> mask = TOperator.IsQuickReturn(result);
+            if (mask != Vector512<T>.Zero)
+            {
+                return IndexOfFirstMatch(mask);
+            }
+
+            // Initialize indices.
+            Vector512<uint> indexIncrement = Vector512.Create((uint)Vector512<uint>.Count);
+            Vector512<uint> resultIndex1 = Vector512<uint>.Indices;
+            Vector512<uint> resultIndex2 = resultIndex1 + indexIncrement;
+            Vector512<uint> currentIndex = resultIndex2 + indexIncrement;
+            ReadOnlySpan<T> span = x.Slice(Vector512<T>.Count);
+
+            while (!span.IsEmpty)
+            {
+                Vector512<T> current;
+                if (span.Length >= Vector512<T>.Count)
+                {
+                    current = Vector512.Create(span);
+                    span = span.Slice(Vector512<T>.Count);
+                }
+                else
+                {
+                    // Process a final back-shifted to cover remaining elements in x in one vector.
+                    int start = x.Length - Vector512<T>.Count;
+                    current = Vector512.Create(x.Slice(start));
+                    currentIndex = Vector512.Create((uint)start) + Vector512<uint>.Indices;
+                    span = ReadOnlySpan<T>.Empty;
+                }
+
+                // Quick return if possible.
+                mask = TOperator.IsQuickReturn(current);
+                if (mask != Vector512<T>.Zero)
+                {
+                    return (int)currentIndex.ToScalar() + IndexOfFirstMatch(mask);
+                }
+
+                // Get mask for which lanes that should have result updated, also widen it for updating the indices.
+                mask = TOperator.Compare(current, result);
+                (Vector512<int> mask1, Vector512<int> mask2) = Vector512.Widen(mask.AsInt16());
+
+                // Update result and indices.
+                result = ElementWiseSelect(mask, current, result);
+                resultIndex1 = ElementWiseSelect(mask1.AsUInt32(), currentIndex, resultIndex1);
+                currentIndex += indexIncrement;
+                resultIndex2 = ElementWiseSelect(mask2.AsUInt32(), currentIndex, resultIndex2);
+                currentIndex += indexIncrement;
+            }
+
+            {
+                // Where result does not bitwise-equal the aggregate min/max value; replace indices with uint.MaxValue. Then find the min index.
+                T aggResult = TOperator.Aggregate(result);
+                Vector512<short> aggMask = ~Vector512.Equals(result.AsInt16(), Vector512.Create(aggResult).AsInt16());
+
+                (Vector512<int> mask1, Vector512<int> mask2) = Vector512.Widen(aggMask);
+                Vector512<uint> aggIndex = resultIndex1 | mask1.AsUInt32();
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex2 | mask2.AsUInt32());
+
+                return (int)HorizontalAggregate<uint, MinOperator<uint>>(aggIndex);
+            }
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector128<T> IndexLessThan<T>(Vector128<T> indices1, Vector128<T> indices2) =>
-            sizeof(T) == sizeof(long) ? Vector128.LessThan(indices1.AsInt64(), indices2.AsInt64()).As<long, T>() :
-            sizeof(T) == sizeof(int) ? Vector128.LessThan(indices1.AsInt32(), indices2.AsInt32()).As<int, T>() :
-            sizeof(T) == sizeof(short) ? Vector128.LessThan(indices1.AsInt16(), indices2.AsInt16()).As<short, T>() :
-            Vector128.LessThan(indices1.AsByte(), indices2.AsByte()).As<byte, T>();
+        private static int IndexOfMinMaxVector512Size1<T, TOperator>(ReadOnlySpan<T> x)
+            where T : INumber<T> where TOperator : struct, IIndexOfMinMaxOperator<T>
+        {
+            Debug.Assert(sizeof(T) == 1);
+
+            // Initialize result by reading first vector and quick return if possible.
+            Vector512<T> result = Vector512.Create(x);
+            Vector512<T> mask = TOperator.IsQuickReturn(result);
+            if (mask != Vector512<T>.Zero)
+            {
+                return IndexOfFirstMatch(mask);
+            }
+
+            // Initialize indices.
+            Vector512<uint> indexIncrement = Vector512.Create((uint)Vector512<uint>.Count);
+            Vector512<uint> resultIndex1 = Vector512<uint>.Indices;
+            Vector512<uint> resultIndex2 = resultIndex1 + indexIncrement;
+            Vector512<uint> resultIndex3 = resultIndex2 + indexIncrement;
+            Vector512<uint> resultIndex4 = resultIndex3 + indexIncrement;
+            Vector512<uint> currentIndex = resultIndex4 + indexIncrement;
+            ReadOnlySpan<T> span = x.Slice(Vector512<T>.Count);
+
+            while (!span.IsEmpty)
+            {
+                Vector512<T> current;
+                if (span.Length >= Vector512<T>.Count)
+                {
+                    current = Vector512.Create(span);
+                    span = span.Slice(Vector512<T>.Count);
+                }
+                else
+                {
+                    // Process a final back-shifted to cover remaining elements in x in one vector.
+                    int start = x.Length - Vector512<T>.Count;
+                    current = Vector512.Create(x.Slice(start));
+                    currentIndex = Vector512.Create((uint)start) + Vector512<uint>.Indices;
+                    span = ReadOnlySpan<T>.Empty;
+                }
+
+                // Quick return if possible.
+                mask = TOperator.IsQuickReturn(current);
+                if (mask != Vector512<T>.Zero)
+                {
+                    return (int)currentIndex.ToScalar() + IndexOfFirstMatch(mask);
+                }
+
+                // Get mask for which lanes that should have result updated, also widen it for updating the indices.
+                mask = TOperator.Compare(current, result);
+                (Vector512<short> lowerMask, Vector512<short> upperMask) = Vector512.Widen(mask.AsSByte());
+                (Vector512<int> mask1, Vector512<int> mask2) = Vector512.Widen(lowerMask);
+                (Vector512<int> mask3, Vector512<int> mask4) = Vector512.Widen(upperMask);
+
+                // Update result and indices.
+                result = ElementWiseSelect(mask, current, result);
+                resultIndex1 = ElementWiseSelect(mask1.AsUInt32(), currentIndex, resultIndex1);
+                currentIndex += indexIncrement;
+                resultIndex2 = ElementWiseSelect(mask2.AsUInt32(), currentIndex, resultIndex2);
+                currentIndex += indexIncrement;
+                resultIndex3 = ElementWiseSelect(mask3.AsUInt32(), currentIndex, resultIndex3);
+                currentIndex += indexIncrement;
+                resultIndex4 = ElementWiseSelect(mask4.AsUInt32(), currentIndex, resultIndex4);
+                currentIndex += indexIncrement;
+            }
+
+            {
+                // Where result does not bitwise-equal the aggregate min/max value; replace indices with uint.MaxValue. Then find the min index.
+                T aggResult = TOperator.Aggregate(result);
+                Vector512<sbyte> aggMask = ~Vector512.Equals(result.AsSByte(), Vector512.Create(aggResult).AsSByte());
+
+                (Vector512<short> lowerMask, Vector512<short> upperMask) = Vector512.Widen(aggMask);
+                (Vector512<int> mask1, Vector512<int> mask2) = Vector512.Widen(lowerMask);
+                (Vector512<int> mask3, Vector512<int> mask4) = Vector512.Widen(upperMask);
+                Vector512<uint> aggIndex = resultIndex1 | mask1.AsUInt32();
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex2 | mask2.AsUInt32());
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex3 | mask3.AsUInt32());
+                aggIndex = MinOperator<uint>.Invoke(aggIndex, resultIndex4 | mask4.AsUInt32());
+
+                return (int)HorizontalAggregate<uint, MinOperator<uint>>(aggIndex);
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMax.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMax.cs
index f40f7e1e2e2ba0..12292dac6b9a7b 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMax.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMax.cs
@@ -1,9 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Diagnostics;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
@@ -29,394 +27,75 @@ public static int IndexOfMax<T>(ReadOnlySpan<T> x)
             IndexOfMinMaxCore<T, IndexOfMaxOperator<T>>(x);
 
         /// <summary>Returns the index of MathF.Max(x, y)</summary>
-        internal readonly struct IndexOfMaxOperator<T> : IIndexOfOperator<T> where T : INumber<T>
+        internal readonly struct IndexOfMaxOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
         {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector128<T> result, Vector128<T> current, ref Vector128<T> resultIndex, Vector128<T> currentIndex)
-            {
-                Vector128<T> useResult = Vector128.GreaterThan(result, current);
-                Vector128<T> equalMask = Vector128.Equals(result, current);
-
-                if (equalMask != Vector128<T>.Zero)
-                {
-                    Vector128<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(current));
-                        Vector128<T> currentNegative = IsNegative(current);
-                        Vector128<T> sameSign = Vector128.Equals(IsNegative(result).AsInt32(), currentNegative.AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, currentNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
-                }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
-            }
+            public static T Aggregate(Vector128<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x);
+            public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x);
+            public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector256<T> result, Vector256<T> current, ref Vector256<T> resultIndex, Vector256<T> currentIndex)
-            {
-                Vector256<T> useResult = Vector256.GreaterThan(result, current);
-                Vector256<T> equalMask = Vector256.Equals(result, current);
-
-                if (equalMask != Vector256<T>.Zero)
-                {
-                    Vector256<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(current));
-                        Vector256<T> currentNegative = IsNegative(current);
-                        Vector256<T> sameSign = Vector256.Equals(IsNegative(result).AsInt32(), currentNegative.AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, currentNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
-                }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
-            }
-
+            public static bool IsQuickReturn(T value) => T.IsNaN(value);
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex)
-            {
-                Vector512<T> useResult = Vector512.GreaterThan(result, current);
-                Vector512<T> equalMask = Vector512.Equals(result, current);
-
-                if (equalMask != Vector512<T>.Zero)
-                {
-                    Vector512<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(current));
-                        Vector512<T> currentNegative = IsNegative(current);
-                        Vector512<T> sameSign = Vector512.Equals(IsNegative(result).AsInt32(), currentNegative.AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, currentNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
-                }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
-            }
+            public static Vector128<T> IsQuickReturn(Vector128<T> value) => IsNaN(value);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector256<T> IsQuickReturn(Vector256<T> value) => IsNaN(value);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector512<T> IsQuickReturn(Vector512<T> value) => IsNaN(value);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(ref T result, T current, int resultIndex, int currentIndex)
+            public static bool Compare(T x, T y)
             {
-                if (result == current)
+                if (x == y)
                 {
-                    bool resultNegative = IsNegative(result);
-                    if ((resultNegative == IsNegative(current)) ? (currentIndex < resultIndex) : resultNegative)
-                    {
-                        result = current;
-                        return currentIndex;
-                    }
+                    return T.IsPositive(x) && T.IsNegative(y);
                 }
-                else if (current > result)
+                else
                 {
-                    result = current;
-                    return currentIndex;
+                    return x > y;
                 }
-
-                return resultIndex;
             }
-        }
-
-        private static unsafe int IndexOfMinMaxCore<T, TIndexOfMinMax>(ReadOnlySpan<T> x)
-    where T : INumber<T>
-    where TIndexOfMinMax : struct, IIndexOfOperator<T>
-        {
-            if (x.IsEmpty)
-            {
-                return -1;
-            }
-
-            // This matches the IEEE 754:2019 `maximum`/`minimum` functions.
-            // It propagates NaN inputs back to the caller and
-            // otherwise returns the index of the greater of the inputs.
-            // It treats +0 as greater than -0 as per the specification.
 
-            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count)
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector128<T> Compare(Vector128<T> x, Vector128<T> y)
             {
-                Debug.Assert(sizeof(T) is 1 or 2 or 4 or 8);
-
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                static Vector512<T> CreateVector512T(int i) =>
-                    sizeof(T) == sizeof(long) ? Vector512.Create((long)i).As<long, T>() :
-                    sizeof(T) == sizeof(int) ? Vector512.Create(i).As<int, T>() :
-                    sizeof(T) == sizeof(short) ? Vector512.Create((short)i).As<short, T>() :
-                    Vector512.Create((byte)i).As<byte, T>();
-
-                ref T xRef = ref MemoryMarshal.GetReference(x);
-                Vector512<T> resultIndex =
-                    sizeof(T) == sizeof(long) ? Vector512<long>.Indices.As<long, T>() :
-                    sizeof(T) == sizeof(int) ? Vector512<int>.Indices.As<int, T>() :
-                    sizeof(T) == sizeof(short) ? Vector512<short>.Indices.As<short, T>() :
-                    Vector512<byte>.Indices.As<byte, T>();
-                Vector512<T> currentIndex = resultIndex;
-                Vector512<T> increment = CreateVector512T(Vector512<T>.Count);
-
-                // Load the first vector as the initial set of results, and bail immediately
-                // to scalar handling if it contains any NaNs (which don't compare equally to themselves).
-                Vector512<T> result = Vector512.LoadUnsafe(ref xRef);
-                Vector512<T> current;
-
-                Vector512<T> nanMask;
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    nanMask = ~Vector512.Equals(result, result);
-                    if (nanMask != Vector512<T>.Zero)
-                    {
-                        return IndexOfFirstMatch(nanMask);
-                    }
+                    Vector128<T> equalResult = IsPositive(x) & IsNegative(y);
+                    return Vector128.GreaterThan(x, y) | (Vector128.Equals(x, y) & equalResult);
                 }
-
-                int oneVectorFromEnd = x.Length - Vector512<T>.Count;
-                int i = Vector512<T>.Count;
-
-                // Aggregate additional vectors into the result as long as there's at least one full vector left to process.
-                while (i <= oneVectorFromEnd)
+                else
                 {
-                    // Load the next vector, and early exit on NaN.
-                    current = Vector512.LoadUnsafe(ref xRef, (uint)i);
-                    currentIndex += increment;
-
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        nanMask = ~Vector512.Equals(current, current);
-                        if (nanMask != Vector512<T>.Zero)
-                        {
-                            return i + IndexOfFirstMatch(nanMask);
-                        }
-                    }
-
-                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
-
-                    i += Vector512<T>.Count;
+                    return Vector128.GreaterThan(x, y);
                 }
-
-                // If any elements remain, handle them in one final vector.
-                if (i != x.Length)
-                {
-                    current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count));
-                    currentIndex += CreateVector512T(x.Length - i);
-
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        nanMask = ~Vector512.Equals(current, current);
-                        if (nanMask != Vector512<T>.Zero)
-                        {
-                            int indexInVectorOfFirstMatch = IndexOfFirstMatch(nanMask);
-                            return typeof(T) == typeof(double) ?
-                                (int)(long)(object)currentIndex.As<T, long>()[indexInVectorOfFirstMatch] :
-                                (int)(object)currentIndex.As<T, int>()[indexInVectorOfFirstMatch];
-                        }
-                    }
-
-                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
-                }
-
-                // Aggregate the lanes in the vector to create the final scalar result.
-                return IndexOfFinalAggregate<T, TIndexOfMinMax>(result, resultIndex);
             }
 
-            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count)
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y)
             {
-                Debug.Assert(sizeof(T) is 1 or 2 or 4 or 8);
-
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                static Vector256<T> CreateVector256T(int i) =>
-                    sizeof(T) == sizeof(long) ? Vector256.Create((long)i).As<long, T>() :
-                    sizeof(T) == sizeof(int) ? Vector256.Create(i).As<int, T>() :
-                    sizeof(T) == sizeof(short) ? Vector256.Create((short)i).As<short, T>() :
-                    Vector256.Create((byte)i).As<byte, T>();
-
-                ref T xRef = ref MemoryMarshal.GetReference(x);
-                Vector256<T> resultIndex =
-                    sizeof(T) == sizeof(long) ? Vector256<long>.Indices.As<long, T>() :
-                    sizeof(T) == sizeof(int) ? Vector256<int>.Indices.As<int, T>() :
-                    sizeof(T) == sizeof(short) ? Vector256<short>.Indices.As<short, T>() :
-                    Vector256<byte>.Indices.As<byte, T>();
-                Vector256<T> currentIndex = resultIndex;
-                Vector256<T> increment = CreateVector256T(Vector256<T>.Count);
-
-                // Load the first vector as the initial set of results, and bail immediately
-                // to scalar handling if it contains any NaNs (which don't compare equally to themselves).
-                Vector256<T> result = Vector256.LoadUnsafe(ref xRef);
-                Vector256<T> current;
-
-                Vector256<T> nanMask;
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    nanMask = ~Vector256.Equals(result, result);
-                    if (nanMask != Vector256<T>.Zero)
-                    {
-                        return IndexOfFirstMatch(nanMask);
-                    }
+                    Vector256<T> equalResult = IsPositive(x) & IsNegative(y);
+                    return Vector256.GreaterThan(x, y) | (Vector256.Equals(x, y) & equalResult);
                 }
-
-                int oneVectorFromEnd = x.Length - Vector256<T>.Count;
-                int i = Vector256<T>.Count;
-
-                // Aggregate additional vectors into the result as long as there's at least one full vector left to process.
-                while (i <= oneVectorFromEnd)
+                else
                 {
-                    // Load the next vector, and early exit on NaN.
-                    current = Vector256.LoadUnsafe(ref xRef, (uint)i);
-                    currentIndex += increment;
-
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        nanMask = ~Vector256.Equals(current, current);
-                        if (nanMask != Vector256<T>.Zero)
-                        {
-                            return i + IndexOfFirstMatch(nanMask);
-                        }
-                    }
-
-                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
-
-                    i += Vector256<T>.Count;
+                    return Vector256.GreaterThan(x, y);
                 }
-
-                // If any elements remain, handle them in one final vector.
-                if (i != x.Length)
-                {
-                    current = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count));
-                    currentIndex += CreateVector256T(x.Length - i);
-
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        nanMask = ~Vector256.Equals(current, current);
-                        if (nanMask != Vector256<T>.Zero)
-                        {
-                            int indexInVectorOfFirstMatch = IndexOfFirstMatch(nanMask);
-                            return typeof(T) == typeof(double) ?
-                                (int)(long)(object)currentIndex.As<T, long>()[indexInVectorOfFirstMatch] :
-                                (int)(object)currentIndex.As<T, int>()[indexInVectorOfFirstMatch];
-                        }
-                    }
-
-                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
-                }
-
-                // Aggregate the lanes in the vector to create the final scalar result.
-                return IndexOfFinalAggregate<T, TIndexOfMinMax>(result, resultIndex);
             }
 
-            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && x.Length >= Vector128<T>.Count)
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y)
             {
-                Debug.Assert(sizeof(T) is 1 or 2 or 4 or 8);
-
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                static Vector128<T> CreateVector128T(int i) =>
-                    sizeof(T) == sizeof(long) ? Vector128.Create((long)i).As<long, T>() :
-                    sizeof(T) == sizeof(int) ? Vector128.Create(i).As<int, T>() :
-                    sizeof(T) == sizeof(short) ? Vector128.Create((short)i).As<short, T>() :
-                    Vector128.Create((byte)i).As<byte, T>();
-
-                ref T xRef = ref MemoryMarshal.GetReference(x);
-                Vector128<T> resultIndex =
-                    sizeof(T) == sizeof(long) ? Vector128<long>.Indices.As<long, T>() :
-                    sizeof(T) == sizeof(int) ? Vector128<int>.Indices.As<int, T>() :
-                    sizeof(T) == sizeof(short) ? Vector128<short>.Indices.As<short, T>() :
-                    Vector128<byte>.Indices.As<byte, T>();
-                Vector128<T> currentIndex = resultIndex;
-                Vector128<T> increment = CreateVector128T(Vector128<T>.Count);
-
-                // Load the first vector as the initial set of results, and bail immediately
-                // to scalar handling if it contains any NaNs (which don't compare equally to themselves).
-                Vector128<T> result = Vector128.LoadUnsafe(ref xRef);
-                Vector128<T> current;
-
-                Vector128<T> nanMask;
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                {
-                    nanMask = ~Vector128.Equals(result, result);
-                    if (nanMask != Vector128<T>.Zero)
-                    {
-                        return IndexOfFirstMatch(nanMask);
-                    }
-                }
-
-                int oneVectorFromEnd = x.Length - Vector128<T>.Count;
-                int i = Vector128<T>.Count;
-
-                // Aggregate additional vectors into the result as long as there's at least one full vector left to process.
-                while (i <= oneVectorFromEnd)
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    // Load the next vector, and early exit on NaN.
-                    current = Vector128.LoadUnsafe(ref xRef, (uint)i);
-                    currentIndex += increment;
-
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        nanMask = ~Vector128.Equals(current, current);
-                        if (nanMask != Vector128<T>.Zero)
-                        {
-                            return i + IndexOfFirstMatch(nanMask);
-                        }
-                    }
-
-                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
-
-                    i += Vector128<T>.Count;
+                    Vector512<T> equalResult = IsPositive(x) & IsNegative(y);
+                    return Vector512.GreaterThan(x, y) | (Vector512.Equals(x, y) & equalResult);
                 }
-
-                // If any elements remain, handle them in one final vector.
-                if (i != x.Length)
+                else
                 {
-                    current = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<T>.Count));
-                    currentIndex += CreateVector128T(x.Length - i);
-
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        nanMask = ~Vector128.Equals(current, current);
-                        if (nanMask != Vector128<T>.Zero)
-                        {
-                            int indexInVectorOfFirstMatch = IndexOfFirstMatch(nanMask);
-                            return typeof(T) == typeof(double) ?
-                                (int)(long)(object)currentIndex.As<T, long>()[indexInVectorOfFirstMatch] :
-                                (int)(object)currentIndex.As<T, int>()[indexInVectorOfFirstMatch];
-                        }
-                    }
-
-                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
+                    return Vector512.GreaterThan(x, y);
                 }
-
-                // Aggregate the lanes in the vector to create the final scalar result.
-                return IndexOfFinalAggregate<T, TIndexOfMinMax>(result, resultIndex);
-            }
-
-            // Scalar path used when either vectorization is not supported or the input is too small to vectorize.
-            T curResult = x[0];
-            int curIn = 0;
-            if (T.IsNaN(curResult))
-            {
-                return curIn;
             }
-
-            for (int i = 1; i < x.Length; i++)
-            {
-                T current = x[i];
-                if (T.IsNaN(current))
-                {
-                    return i;
-                }
-
-                curIn = TIndexOfMinMax.Invoke(ref curResult, current, curIn, i);
-            }
-
-            return curIn;
         }
 
         private static int IndexOfFirstMatch<T>(Vector128<T> mask) =>
@@ -428,23 +107,6 @@ private static int IndexOfFirstMatch<T>(Vector256<T> mask) =>
         private static int IndexOfFirstMatch<T>(Vector512<T> mask) =>
             BitOperations.TrailingZeroCount(mask.ExtractMostSignificantBits());
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe Vector256<T> IndexLessThan<T>(Vector256<T> indices1, Vector256<T> indices2) =>
-            sizeof(T) == sizeof(long) ? Vector256.LessThan(indices1.AsInt64(), indices2.AsInt64()).As<long, T>() :
-            sizeof(T) == sizeof(int) ? Vector256.LessThan(indices1.AsInt32(), indices2.AsInt32()).As<int, T>() :
-            sizeof(T) == sizeof(short) ? Vector256.LessThan(indices1.AsInt16(), indices2.AsInt16()).As<short, T>() :
-            Vector256.LessThan(indices1.AsByte(), indices2.AsByte()).As<byte, T>();
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe Vector512<T> IndexLessThan<T>(Vector512<T> indices1, Vector512<T> indices2) =>
-            sizeof(T) == sizeof(long) ? Vector512.LessThan(indices1.AsInt64(), indices2.AsInt64()).As<long, T>() :
-            sizeof(T) == sizeof(int) ? Vector512.LessThan(indices1.AsInt32(), indices2.AsInt32()).As<int, T>() :
-            sizeof(T) == sizeof(short) ? Vector512.LessThan(indices1.AsInt16(), indices2.AsInt16()).As<short, T>() :
-            Vector512.LessThan(indices1.AsByte(), indices2.AsByte()).As<byte, T>();
-
-        /// <summary>Gets whether the specified <see cref="float"/> is negative.</summary>
-        private static bool IsNegative<T>(T f) where T : INumberBase<T> => T.IsNegative(f);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static unsafe Vector128<T> ElementWiseSelect<T>(Vector128<T> mask, Vector128<T> left, Vector128<T> right)
         {
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxMagnitude.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxMagnitude.cs
index f1f5016a86b13e..a4e16d4f35ece3 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxMagnitude.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxMagnitude.cs
@@ -26,111 +26,78 @@ public static int IndexOfMaxMagnitude<T>(ReadOnlySpan<T> x)
             where T : INumber<T> =>
             IndexOfMinMaxCore<T, IndexOfMaxMagnitudeOperator<T>>(x);
 
-        internal readonly struct IndexOfMaxMagnitudeOperator<T> : IIndexOfOperator<T> where T : INumber<T>
+        internal readonly struct IndexOfMaxMagnitudeOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
         {
+            public static T Aggregate(Vector128<T> x) => HorizontalAggregate<T, MaxMagnitudeOperator<T>>(x);
+            public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MaxMagnitudeOperator<T>>(x);
+            public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MaxMagnitudeOperator<T>>(x);
+
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector128<T> result, Vector128<T> current, ref Vector128<T> resultIndex, Vector128<T> currentIndex)
-            {
-                Vector128<T> resultMag = Vector128.Abs(result), currentMag = Vector128.Abs(current);
-                Vector128<T> useResult = Vector128.GreaterThan(resultMag, currentMag);
-                Vector128<T> equalMask = Vector128.Equals(resultMag, currentMag);
+            public static bool IsQuickReturn(T value) => T.IsNaN(value);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector128<T> IsQuickReturn(Vector128<T> value) => IsNaN(value);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector256<T> IsQuickReturn(Vector256<T> value) => IsNaN(value);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector512<T> IsQuickReturn(Vector512<T> value) => IsNaN(value);
 
-                if (equalMask != Vector128<T>.Zero)
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static bool Compare(T x, T y)
+            {
+                T xMag = T.Abs(x), yMag = T.Abs(y);
+                if (xMag == yMag)
                 {
-                    Vector128<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(current));
-                        Vector128<T> currentNegative = IsNegative(current);
-                        Vector128<T> sameSign = Vector128.Equals(IsNegative(result).AsInt32(), currentNegative.AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, currentNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
+                    return T.IsPositive(x) && T.IsNegative(y);
+                }
+                else
+                {
+                    return xMag > yMag;
                 }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector256<T> result, Vector256<T> current, ref Vector256<T> resultIndex, Vector256<T> currentIndex)
+            public static Vector128<T> Compare(Vector128<T> x, Vector128<T> y)
             {
-                Vector256<T> resultMag = Vector256.Abs(result), currentMag = Vector256.Abs(current);
-                Vector256<T> useResult = Vector256.GreaterThan(resultMag, currentMag);
-                Vector256<T> equalMask = Vector256.Equals(resultMag, currentMag);
-
-                if (equalMask != Vector256<T>.Zero)
+                Vector128<T> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    Vector256<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(current));
-                        Vector256<T> currentNegative = IsNegative(current);
-                        Vector256<T> sameSign = Vector256.Equals(IsNegative(result).AsInt32(), currentNegative.AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, currentNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
+                    Vector128<T> equalResult = IsPositive(x) & IsNegative(y);
+                    return Vector128.GreaterThan(xMag, yMag) | (Vector128.Equals(xMag, yMag) & equalResult);
+                }
+                else
+                {
+                    return Vector128.GreaterThan(xMag, yMag);
                 }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex)
+            public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y)
             {
-                Vector512<T> resultMag = Vector512.Abs(result), currentMag = Vector512.Abs(current);
-                Vector512<T> useResult = Vector512.GreaterThan(resultMag, currentMag);
-                Vector512<T> equalMask = Vector512.Equals(resultMag, currentMag);
-
-                if (equalMask != Vector512<T>.Zero)
+                Vector256<T> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    Vector512<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(current));
-                        Vector512<T> currentNegative = IsNegative(current);
-                        Vector512<T> sameSign = Vector512.Equals(IsNegative(result).AsInt32(), currentNegative.AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, currentNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
+                    Vector256<T> equalResult = IsPositive(x) & IsNegative(y);
+                    return Vector256.GreaterThan(xMag, yMag) | (Vector256.Equals(xMag, yMag) & equalResult);
+                }
+                else
+                {
+                    return Vector256.GreaterThan(xMag, yMag);
                 }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(ref T result, T current, int resultIndex, int currentIndex)
+            public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y)
             {
-                T resultMag = T.Abs(result);
-                T currentMag = T.Abs(current);
-
-                if (resultMag == currentMag)
+                Vector512<T> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    bool resultNegative = IsNegative(result);
-                    if ((resultNegative == IsNegative(current)) ? (currentIndex < resultIndex) : resultNegative)
-                    {
-                        result = current;
-                        return currentIndex;
-                    }
+                    Vector512<T> equalResult = IsPositive(x) & IsNegative(y);
+                    return Vector512.GreaterThan(xMag, yMag) | (Vector512.Equals(xMag, yMag) & equalResult);
                 }
-                else if (currentMag > resultMag)
+                else
                 {
-                    result = current;
-                    return currentIndex;
+                    return Vector512.GreaterThan(xMag, yMag);
                 }
-
-                return resultIndex;
             }
         }
     }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMin.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMin.cs
index 011021b6c0015f..c69e5727147ecd 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMin.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMin.cs
@@ -26,105 +26,74 @@ public static int IndexOfMin<T>(ReadOnlySpan<T> x)
             IndexOfMinMaxCore<T, IndexOfMinOperator<T>>(x);
 
         /// <summary>Returns the index of MathF.Min(x, y)</summary>
-        internal readonly struct IndexOfMinOperator<T> : IIndexOfOperator<T> where T : INumber<T>
+        internal readonly struct IndexOfMinOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
         {
+            public static T Aggregate(Vector128<T> x) => HorizontalAggregate<T, MinOperator<T>>(x);
+            public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MinOperator<T>>(x);
+            public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MinOperator<T>>(x);
+
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector128<T> result, Vector128<T> current, ref Vector128<T> resultIndex, Vector128<T> currentIndex)
-            {
-                Vector128<T> useResult = Vector128.LessThan(result, current);
-                Vector128<T> equalMask = Vector128.Equals(result, current);
+            public static bool IsQuickReturn(T value) => T.IsNaN(value);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector128<T> IsQuickReturn(Vector128<T> value) => IsNaN(value);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector256<T> IsQuickReturn(Vector256<T> value) => IsNaN(value);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector512<T> IsQuickReturn(Vector512<T> value) => IsNaN(value);
 
-                if (equalMask != Vector128<T>.Zero)
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static bool Compare(T x, T y)
+            {
+                if (x == y)
                 {
-                    Vector128<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(result));
-                        Vector128<T> resultNegative = IsNegative(result);
-                        Vector128<T> sameSign = Vector128.Equals(resultNegative.AsInt32(), IsNegative(current).AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, resultNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
+                    return T.IsNegative(x) && T.IsPositive(y);
+                }
+                else
+                {
+                    return x < y;
                 }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector256<T> result, Vector256<T> current, ref Vector256<T> resultIndex, Vector256<T> currentIndex)
+            public static Vector128<T> Compare(Vector128<T> x, Vector128<T> y)
             {
-                Vector256<T> useResult = Vector256.LessThan(result, current);
-                Vector256<T> equalMask = Vector256.Equals(result, current);
-
-                if (equalMask != Vector256<T>.Zero)
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    Vector256<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(result));
-                        Vector256<T> resultNegative = IsNegative(result);
-                        Vector256<T> sameSign = Vector256.Equals(resultNegative.AsInt32(), IsNegative(current).AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, resultNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
+                    Vector128<T> equalResult = IsNegative(x) & IsPositive(y);
+                    return Vector128.LessThan(x, y) | (Vector128.Equals(x, y) & equalResult);
+                }
+                else
+                {
+                    return Vector128.LessThan(x, y);
                 }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex)
+            public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y)
             {
-                Vector512<T> useResult = Vector512.LessThan(result, current);
-                Vector512<T> equalMask = Vector512.Equals(result, current);
-
-                if (equalMask != Vector512<T>.Zero)
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    Vector512<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(result));
-                        Vector512<T> resultNegative = IsNegative(result);
-                        Vector512<T> sameSign = Vector512.Equals(resultNegative.AsInt32(), IsNegative(current).AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, resultNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
+                    Vector256<T> equalResult = IsNegative(x) & IsPositive(y);
+                    return Vector256.LessThan(x, y) | (Vector256.Equals(x, y) & equalResult);
+                }
+                else
+                {
+                    return Vector256.LessThan(x, y);
                 }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(ref T result, T current, int resultIndex, int currentIndex)
+            public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y)
             {
-                if (result == current)
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    bool currentNegative = IsNegative(current);
-                    if ((IsNegative(result) == currentNegative) ? (currentIndex < resultIndex) : currentNegative)
-                    {
-                        result = current;
-                        return currentIndex;
-                    }
+                    Vector512<T> equalResult = IsNegative(x) & IsPositive(y);
+                    return Vector512.LessThan(x, y) | (Vector512.Equals(x, y) & equalResult);
                 }
-                else if (current < result)
+                else
                 {
-                    result = current;
-                    return currentIndex;
+                    return Vector512.LessThan(x, y);
                 }
-
-                return resultIndex;
             }
         }
     }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinMagnitude.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinMagnitude.cs
index 813bcf4637dd12..3682382a3cb0d4 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinMagnitude.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinMagnitude.cs
@@ -26,111 +26,78 @@ public static int IndexOfMinMagnitude<T>(ReadOnlySpan<T> x)
             where T : INumber<T> =>
             IndexOfMinMaxCore<T, IndexOfMinMagnitudeOperator<T>>(x);
 
-        internal readonly struct IndexOfMinMagnitudeOperator<T> : IIndexOfOperator<T> where T : INumber<T>
+        internal readonly struct IndexOfMinMagnitudeOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
         {
+            public static T Aggregate(Vector128<T> x) => HorizontalAggregate<T, MinMagnitudeOperator<T>>(x);
+            public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MinMagnitudeOperator<T>>(x);
+            public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MinMagnitudeOperator<T>>(x);
+
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector128<T> result, Vector128<T> current, ref Vector128<T> resultIndex, Vector128<T> currentIndex)
-            {
-                Vector128<T> resultMag = Vector128.Abs(result), currentMag = Vector128.Abs(current);
-                Vector128<T> useResult = Vector128.LessThan(resultMag, currentMag);
-                Vector128<T> equalMask = Vector128.Equals(resultMag, currentMag);
+            public static bool IsQuickReturn(T value) => T.IsNaN(value);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector128<T> IsQuickReturn(Vector128<T> value) => IsNaN(value);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector256<T> IsQuickReturn(Vector256<T> value) => IsNaN(value);
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector512<T> IsQuickReturn(Vector512<T> value) => IsNaN(value);
 
-                if (equalMask != Vector128<T>.Zero)
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static bool Compare(T x, T y)
+            {
+                T xMag = T.Abs(x), yMag = T.Abs(y);
+                if (xMag == yMag)
                 {
-                    Vector128<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(result));
-                        Vector128<T> resultNegative = IsNegative(result);
-                        Vector128<T> sameSign = Vector128.Equals(resultNegative.AsInt32(), IsNegative(current).AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, resultNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
+                    return T.IsNegative(x) && T.IsPositive(y);
+                }
+                else
+                {
+                    return xMag < yMag;
                 }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector256<T> result, Vector256<T> current, ref Vector256<T> resultIndex, Vector256<T> currentIndex)
+            public static Vector128<T> Compare(Vector128<T> x, Vector128<T> y)
             {
-                Vector256<T> resultMag = Vector256.Abs(result), currentMag = Vector256.Abs(current);
-                Vector256<T> useResult = Vector256.LessThan(resultMag, currentMag);
-                Vector256<T> equalMask = Vector256.Equals(resultMag, currentMag);
-
-                if (equalMask != Vector256<T>.Zero)
+                Vector128<T> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    Vector256<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(result));
-                        Vector256<T> resultNegative = IsNegative(result);
-                        Vector256<T> sameSign = Vector256.Equals(resultNegative.AsInt32(), IsNegative(current).AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, resultNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
+                    Vector128<T> equalResult = IsNegative(x) & IsPositive(y);
+                    return Vector128.LessThan(xMag, yMag) | (Vector128.Equals(xMag, yMag) & equalResult);
+                }
+                else
+                {
+                    return Vector128.LessThan(xMag, yMag);
                 }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex)
+            public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y)
             {
-                Vector512<T> resultMag = Vector512.Abs(result), currentMag = Vector512.Abs(current);
-                Vector512<T> useResult = Vector512.LessThan(resultMag, currentMag);
-                Vector512<T> equalMask = Vector512.Equals(resultMag, currentMag);
-
-                if (equalMask != Vector512<T>.Zero)
+                Vector256<T> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    Vector512<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
-                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
-                    {
-                        // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(result));
-                        Vector512<T> resultNegative = IsNegative(result);
-                        Vector512<T> sameSign = Vector512.Equals(resultNegative.AsInt32(), IsNegative(current).AsInt32()).As<int, T>();
-                        useResult |= equalMask & ElementWiseSelect(sameSign, lessThanIndexMask, resultNegative);
-                    }
-                    else
-                    {
-                        useResult |= equalMask & lessThanIndexMask;
-                    }
+                    Vector256<T> equalResult = IsNegative(x) & IsPositive(y);
+                    return Vector256.LessThan(xMag, yMag) | (Vector256.Equals(xMag, yMag) & equalResult);
+                }
+                else
+                {
+                    return Vector256.LessThan(xMag, yMag);
                 }
-
-                result = ElementWiseSelect(useResult, result, current);
-                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(ref T result, T current, int resultIndex, int currentIndex)
+            public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y)
             {
-                T resultMag = T.Abs(result);
-                T currentMag = T.Abs(current);
-
-                if (resultMag == currentMag)
+                Vector512<T> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
                 {
-                    bool currentNegative = IsNegative(current);
-                    if ((IsNegative(result) == currentNegative) ? (currentIndex < resultIndex) : currentNegative)
-                    {
-                        result = current;
-                        return currentIndex;
-                    }
+                    Vector512<T> equalResult = IsNegative(x) & IsPositive(y);
+                    return Vector512.LessThan(xMag, yMag) | (Vector512.Equals(xMag, yMag) & equalResult);
                 }
-                else if (currentMag < resultMag)
+                else
                 {
-                    result = current;
-                    return currentIndex;
+                    return Vector512.LessThan(xMag, yMag);
                 }
-
-                return resultIndex;
             }
         }
     }
diff --git a/src/libraries/System.Numerics.Tensors/tests/Helpers.cs b/src/libraries/System.Numerics.Tensors/tests/Helpers.cs
index 4e5e89bbb3cad8..ef8ae1406a1979 100644
--- a/src/libraries/System.Numerics.Tensors/tests/Helpers.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/Helpers.cs
@@ -10,6 +10,9 @@ namespace System.Numerics.Tensors.Tests
 {
     public static class Helpers
     {
+        public static int SizeGraterThanByte => 260;
+        public static int SizeGraterThanInt16 => 65540;
+
         public static IEnumerable<int> TensorLengthsIncluding0 => Enumerable.Range(0, 257);
 
         public static IEnumerable<int> TensorLengths => Enumerable.Range(1, 256);
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
index f505a2ab77eb1f..35b294e157f570 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
@@ -320,39 +320,100 @@ private static void ConvertToIntegerNativeImpl<TFrom, TTo>()
 
     // The tests for some types have been marked as OuterLoop simply to decrease inner loop testing time.
 
-    public class DoubleGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<double> { }
-    public class SingleGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<float> { }
+    public class DoubleGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<double>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+    }
+
+    public class SingleGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<float>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+    }
+
     public class HalfGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<Half>
     {
+        protected override int? IndexOfSizeExceedingMaxValue() => Helpers.SizeGraterThanInt16;
         protected override void AssertEqualTolerance(Half expected, Half actual, Half? tolerance = null) =>
             base.AssertEqualTolerance(expected, actual, tolerance ?? Half.CreateTruncating(0.001));
     }
 
     [OuterLoop]
-    public class NFloatGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<NFloat> { }
+    public class NFloatGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<NFloat>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+    }
 
     [OuterLoop]
-    public class SByteGenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<sbyte> { }
-    public class Int16GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<short> { }
+    public class SByteGenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<sbyte>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => Helpers.SizeGraterThanByte;
+    }
+
+    public class Int16GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<short>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => Helpers.SizeGraterThanInt16;
+    }
+
     [OuterLoop]
-    public class Int32GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<int> { }
-    public class Int64GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<long> { }
+    public class Int32GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<int>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+    }
+
+    public class Int64GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<long>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+    }
+
     [OuterLoop]
-    public class IntPtrGenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<nint> { }
-    public class Int128GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<Int128> { }
+    public class IntPtrGenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<nint>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+    }
+
+    public class Int128GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<Int128>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+    }
+
+    public class ByteGenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<byte>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => Helpers.SizeGraterThanByte;
+    }
 
-    public class ByteGenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<byte> { }
     [OuterLoop]
-    public class UInt16GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<ushort> { }
+    public class UInt16GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<ushort>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => Helpers.SizeGraterThanInt16;
+    }
+
     [OuterLoop]
-    public class CharGenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<char> { }
-    public class UInt32GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<uint> { }
+    public class CharGenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<char>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => Helpers.SizeGraterThanInt16;
+    }
+
+    public class UInt32GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<uint>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+    }
+
     [OuterLoop]
-    public class UInt64GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<ulong> { }
+    public class UInt64GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<ulong>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+    }
+
+    public class UIntPtrGenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<nuint>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+    }
 
-    public class UIntPtrGenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<nuint> { }
     [OuterLoop]
-    public class UInt128GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<UInt128> { }
+    public class UInt128GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<UInt128>
+    {
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+    }
 
     public unsafe abstract class GenericFloatingPointNumberTensorPrimitivesTests<T> : GenericNumberTensorPrimitivesTests<T>
         where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.NonGeneric.Single.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.NonGeneric.Single.cs
index 707e27d2fae419..d7279b3cb0603b 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.NonGeneric.Single.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.NonGeneric.Single.cs
@@ -91,6 +91,8 @@ protected override float MinMagnitude(float x, float y)
         protected override float NegativeOne => -1f;
         protected override float MinValue => float.MinValue;
 
+        protected override int? IndexOfSizeExceedingMaxValue() => null;
+
         protected override IEnumerable<(int Length, float Element)> VectorLengthAndIteratedRange(float min, float max, float increment)
         {
             foreach (int length in new[] { 4, 8, 16 })
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
index b21666434904f1..ef1bb01e82a402 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
@@ -106,6 +106,8 @@ public abstract class TensorPrimitivesTests<T> where T : unmanaged, IEquatable<T
 
         protected virtual bool IsFloatingPoint => typeof(T) == typeof(float) || typeof(T) == typeof(double);
 
+        protected abstract int? IndexOfSizeExceedingMaxValue();
+
         protected abstract T ConvertFromSingle(float f);
 
         protected abstract IEnumerable<T> GetSpecialValues();
@@ -1134,6 +1136,18 @@ public void IndexOfMax_Negative0LesserThanPositive0()
             Assert.Equal(1, IndexOfMax([ConvertFromSingle(-1),  ConvertFromSingle(-0f)]));
             Assert.Equal(2, IndexOfMax([ConvertFromSingle(-1),  ConvertFromSingle(-0f), ConvertFromSingle(1f)]));
         }
+
+        [Fact]
+        public void IndexOfMax_IndexAboveMaxValue()
+        {
+            var size = IndexOfSizeExceedingMaxValue();
+            if (size == null) return;
+
+            using BoundedMemory<T> x = CreateTensor(size.Value);
+            x.Span.Fill(ConvertFromSingle(1));
+            x.Span[size.Value - 1] = ConvertFromSingle(2);
+            Assert.Equal(size.Value - 1, IndexOfMax(x));
+        }
         #endregion
 
         #region IndexOfMaxMagnitude
@@ -1211,6 +1225,18 @@ public void IndexOfMaxMagnitude_Negative0LesserThanPositive0()
             Assert.Equal(0, IndexOfMaxMagnitude([ConvertFromSingle(-1),  ConvertFromSingle(-0f)]));
             Assert.Equal(2, IndexOfMaxMagnitude([ConvertFromSingle(-1),  ConvertFromSingle(-0f), ConvertFromSingle(1f)]));
         }
+
+        [Fact]
+        public void IndexOfMaxMagnitude_IndexAboveMaxValue()
+        {
+            var size = IndexOfSizeExceedingMaxValue();
+            if (size == null) return;
+
+            using BoundedMemory<T> x = CreateTensor(size.Value);
+            x.Span.Fill(ConvertFromSingle(1));
+            x.Span[size.Value - 1] = ConvertFromSingle(2);
+            Assert.Equal(size.Value - 1, IndexOfMaxMagnitude(x));
+        }
         #endregion
 
         #region IndexOfMin
@@ -1263,6 +1289,18 @@ public void IndexOfMin_Negative0LesserThanPositive0()
             Assert.Equal(0, IndexOfMin([ConvertFromSingle(-1),  ConvertFromSingle(-0f)]));
             Assert.Equal(0, IndexOfMin([ConvertFromSingle(-1),  ConvertFromSingle(-0f), ConvertFromSingle(1f)]));
         }
+
+        [Fact]
+        public void IndexOfMin_IndexAboveMaxValue()
+        {
+            var size = IndexOfSizeExceedingMaxValue();
+            if (size == null) return;
+
+            using BoundedMemory<T> x = CreateTensor(size.Value);
+            x.Span.Fill(ConvertFromSingle(1));
+            x.Span[size.Value - 1] = ConvertFromSingle(0);
+            Assert.Equal(size.Value - 1, IndexOfMin(x));
+        }
         #endregion
 
         #region IndexOfMinMagnitude
@@ -1340,6 +1378,18 @@ public void IndexOfMinMagnitude_Negative0LesserThanPositive0()
             Assert.Equal(1, IndexOfMinMagnitude([ConvertFromSingle(-1),  ConvertFromSingle(-0f)]));
             Assert.Equal(1, IndexOfMinMagnitude([ConvertFromSingle(-1),  ConvertFromSingle(-0f), ConvertFromSingle(1f)]));
         }
+
+        [Fact]
+        public void IndexOfMinMagnitude_IndexAboveMaxValue()
+        {
+            var size = IndexOfSizeExceedingMaxValue();
+            if (size == null) return;
+
+            using BoundedMemory<T> x = CreateTensor(size.Value);
+            x.Span.Fill(ConvertFromSingle(1));
+            x.Span[size.Value - 1] = ConvertFromSingle(0);
+            Assert.Equal(size.Value - 1, IndexOfMinMagnitude(x));
+        }
         #endregion
 
         #region Log