From dd15cc03bb90912ed1136e1bc9028493d378132c Mon Sep 17 00:00:00 2001
From: Linus Hamlin <linus.hamlin@soderbergpartners.se>
Date: Thu, 18 Jun 2026 16:34:13 +0200
Subject: [PATCH 1/3] Add ShouldEarlyExitOnNan

---
 ...TensorPrimitives.IIndexOfMinMaxOperator.cs | 97 +++++++++++++------
 .../netcore/TensorPrimitives.IndexOfMax.cs    |  1 +
 .../TensorPrimitives.IndexOfMaxMagnitude.cs   |  1 +
 .../netcore/TensorPrimitives.IndexOfMin.cs    |  1 +
 .../TensorPrimitives.IndexOfMinMagnitude.cs   |  1 +
 5 files changed, 74 insertions(+), 27 deletions(-)

diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IIndexOfMinMaxOperator.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IIndexOfMinMaxOperator.cs
index 9887a65da80968..b2963f97320316 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IIndexOfMinMaxOperator.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IIndexOfMinMaxOperator.cs
@@ -11,6 +11,7 @@ public static unsafe partial class TensorPrimitives
     {
         private interface IIndexOfMinMaxOperator<T>
         {
+            static abstract bool ShouldEarlyExitOnNan { get; }
             static abstract T Aggregate(Vector128<T> value);
             static abstract T Aggregate(Vector256<T> value);
             static abstract T Aggregate(Vector512<T> value);
@@ -60,7 +61,7 @@ private static int IndexOfMinMaxFallback<T, TOperator>(ReadOnlySpan<T> x)
         {
             T result = x[0];
             int resultIndex = 0;
-            if (T.IsNaN(result))
+            if (TOperator.ShouldEarlyExitOnNan && T.IsNaN(result))
             {
                 return resultIndex;
             }
@@ -68,7 +69,7 @@ private static int IndexOfMinMaxFallback<T, TOperator>(ReadOnlySpan<T> x)
             for (int i = 1; i < x.Length; i++)
             {
                 T current = x[i];
-                if (T.IsNaN(current))
+                if (TOperator.ShouldEarlyExitOnNan && T.IsNaN(current))
                 {
                     return i;
                 }
@@ -79,7 +80,7 @@ private static int IndexOfMinMaxFallback<T, TOperator>(ReadOnlySpan<T> x)
                 }
             }
 
-            return resultIndex;
+            return !TOperator.ShouldEarlyExitOnNan && T.IsNaN(result) ? -1 : resultIndex;
         }
 
         private static int IndexOfMinMaxVectorized128Size4Plus<T, TOperator, TInt>(ReadOnlySpan<T> x)
@@ -91,7 +92,7 @@ private static int IndexOfMinMaxVectorized128Size4Plus<T, TOperator, TInt>(ReadO
 
             // Initialize result by reading first vector and quick return if possible.
             Vector128<T> result = Vector128.Create(x);
-            if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+            if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
             {
                 Vector128<T> nanMask = IsNaN(result);
                 if (nanMask != Vector128<T>.Zero)
@@ -124,7 +125,7 @@ private static int IndexOfMinMaxVectorized128Size4Plus<T, TOperator, TInt>(ReadO
                 }
 
                 // Quick return if possible.
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
                 {
                     Vector128<T> nanMask = IsNaN(current);
                     if (nanMask != Vector128<T>.Zero)
@@ -145,8 +146,14 @@ private static int IndexOfMinMaxVectorized128Size4Plus<T, TOperator, TInt>(ReadO
             {
                 // 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);
+                if (!TOperator.ShouldEarlyExitOnNan && T.IsNaN(aggResult))
+                {
+                    return -1;
+                }
+
                 Vector128<TInt> aggMask = ~Vector128.Equals(result.As<T, TInt>(), Vector128.Create(aggResult).As<T, TInt>());
                 Vector128<TInt> aggIndex = resultIndex | aggMask;
+
                 return int.CreateTruncating(HorizontalAggregate<TInt, MinOperator<TInt>>(aggIndex));
             }
         }
@@ -158,7 +165,7 @@ private static int IndexOfMinMaxVectorized128Size2<T, TOperator>(ReadOnlySpan<T>
 
             // Initialize result by reading first vector and quick return if possible.
             Vector128<T> result = Vector128.Create(x);
-            if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+            if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
             {
                 Vector128<T> nanMask = IsNaN(result);
                 if (nanMask != Vector128<T>.Zero)
@@ -192,7 +199,7 @@ private static int IndexOfMinMaxVectorized128Size2<T, TOperator>(ReadOnlySpan<T>
                 }
 
                 // Quick return if possible.
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                if (TOperator.ShouldEarlyExitOnNan && typeof(T) == typeof(float) || typeof(T) == typeof(double))
                 {
                     Vector128<T> nanMask = IsNaN(current);
                     if (nanMask != Vector128<T>.Zero)
@@ -216,8 +223,12 @@ private static int IndexOfMinMaxVectorized128Size2<T, TOperator>(ReadOnlySpan<T>
             {
                 // 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());
+                if (!TOperator.ShouldEarlyExitOnNan && T.IsNaN(aggResult))
+                {
+                    return -1;
+                }
 
+                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());
@@ -233,7 +244,7 @@ private static int IndexOfMinMaxVectorized128Size1<T, TOperator>(ReadOnlySpan<T>
 
             // Initialize result by reading first vector and quick return if possible.
             Vector128<T> result = Vector128.Create(x);
-            if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+            if (TOperator.ShouldEarlyExitOnNan && typeof(T) == typeof(float) || typeof(T) == typeof(double))
             {
                 Vector128<T> nanMask = IsNaN(result);
                 if (nanMask != Vector128<T>.Zero)
@@ -269,7 +280,7 @@ private static int IndexOfMinMaxVectorized128Size1<T, TOperator>(ReadOnlySpan<T>
                 }
 
                 // Quick return if possible.
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
                 {
                     Vector128<T> nanMask = IsNaN(current);
                     if (nanMask != Vector128<T>.Zero)
@@ -299,8 +310,12 @@ private static int IndexOfMinMaxVectorized128Size1<T, TOperator>(ReadOnlySpan<T>
             {
                 // 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());
+                if (!TOperator.ShouldEarlyExitOnNan && T.IsNaN(aggResult))
+                {
+                    return -1;
+                }
 
+                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);
@@ -322,7 +337,7 @@ private static int IndexOfMinMaxVectorized256Size4Plus<T, TOperator, TInt>(ReadO
 
             // Initialize result by reading first vector and quick return if possible.
             Vector256<T> result = Vector256.Create(x);
-            if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+            if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
             {
                 Vector256<T> nanMask = IsNaN(result);
                 if (nanMask != Vector256<T>.Zero)
@@ -355,7 +370,7 @@ private static int IndexOfMinMaxVectorized256Size4Plus<T, TOperator, TInt>(ReadO
                 }
 
                 // Quick return if possible.
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
                 {
                     Vector256<T> nanMask = IsNaN(current);
                     if (nanMask != Vector256<T>.Zero)
@@ -376,8 +391,14 @@ private static int IndexOfMinMaxVectorized256Size4Plus<T, TOperator, TInt>(ReadO
             {
                 // 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);
+                if (!TOperator.ShouldEarlyExitOnNan && T.IsNaN(aggResult))
+                {
+                    return -1;
+                }
+
                 Vector256<TInt> aggMask = ~Vector256.Equals(result.As<T, TInt>(), Vector256.Create(aggResult).As<T, TInt>());
                 Vector256<TInt> aggIndex = resultIndex | aggMask;
+
                 return int.CreateTruncating(HorizontalAggregate<TInt, MinOperator<TInt>>(aggIndex));
             }
         }
@@ -389,7 +410,7 @@ private static int IndexOfMinMaxVectorized256Size2<T, TOperator>(ReadOnlySpan<T>
 
             // Initialize result by reading first vector and quick return if possible.
             Vector256<T> result = Vector256.Create(x);
-            if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+            if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
             {
                 Vector256<T> nanMask = IsNaN(result);
                 if (nanMask != Vector256<T>.Zero)
@@ -423,7 +444,7 @@ private static int IndexOfMinMaxVectorized256Size2<T, TOperator>(ReadOnlySpan<T>
                 }
 
                 // Quick return if possible.
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
                 {
                     Vector256<T> nanMask = IsNaN(current);
                     if (nanMask != Vector256<T>.Zero)
@@ -447,8 +468,12 @@ private static int IndexOfMinMaxVectorized256Size2<T, TOperator>(ReadOnlySpan<T>
             {
                 // 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());
+                if (!TOperator.ShouldEarlyExitOnNan && T.IsNaN(aggResult))
+                {
+                    return -1;
+                }
 
+                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());
@@ -464,7 +489,7 @@ private static int IndexOfMinMaxVectorized256Size1<T, TOperator>(ReadOnlySpan<T>
 
             // Initialize result by reading first vector and quick return if possible.
             Vector256<T> result = Vector256.Create(x);
-            if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+            if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
             {
                 Vector256<T> nanMask = IsNaN(result);
                 if (nanMask != Vector256<T>.Zero)
@@ -500,7 +525,7 @@ private static int IndexOfMinMaxVectorized256Size1<T, TOperator>(ReadOnlySpan<T>
                 }
 
                 // Quick return if possible.
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
                 {
                     Vector256<T> nanMask = IsNaN(current);
                     if (nanMask != Vector256<T>.Zero)
@@ -530,8 +555,12 @@ private static int IndexOfMinMaxVectorized256Size1<T, TOperator>(ReadOnlySpan<T>
             {
                 // 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());
+                if (!TOperator.ShouldEarlyExitOnNan && T.IsNaN(aggResult))
+                {
+                    return -1;
+                }
 
+                Vector256<sbyte> aggMask = ~Vector256.Equals(result.AsSByte(), Vector256.Create(aggResult).AsSByte());
                 (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);
@@ -553,7 +582,7 @@ private static int IndexOfMinMaxVectorized512Size4Plus<T, TOperator, TInt>(ReadO
 
             // Initialize result by reading first vector and quick return if possible.
             Vector512<T> result = Vector512.Create(x);
-            if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+            if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
             {
                 Vector512<T> nanMask = IsNaN(result);
                 if (nanMask != Vector512<T>.Zero)
@@ -586,7 +615,7 @@ private static int IndexOfMinMaxVectorized512Size4Plus<T, TOperator, TInt>(ReadO
                 }
 
                 // Quick return if possible.
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
                 {
                     Vector512<T> nanMask = IsNaN(current);
                     if (nanMask != Vector512<T>.Zero)
@@ -607,8 +636,14 @@ private static int IndexOfMinMaxVectorized512Size4Plus<T, TOperator, TInt>(ReadO
             {
                 // 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);
+                if (!TOperator.ShouldEarlyExitOnNan && T.IsNaN(aggResult))
+                {
+                    return -1;
+                }
+
                 Vector512<TInt> aggMask = ~Vector512.Equals(result.As<T, TInt>(), Vector512.Create(aggResult).As<T, TInt>());
                 Vector512<TInt> aggIndex = resultIndex | aggMask;
+
                 return int.CreateTruncating(HorizontalAggregate<TInt, MinOperator<TInt>>(aggIndex));
             }
         }
@@ -620,7 +655,7 @@ private static int IndexOfMinMaxVectorized512Size2<T, TOperator>(ReadOnlySpan<T>
 
             // Initialize result by reading first vector and quick return if possible.
             Vector512<T> result = Vector512.Create(x);
-            if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+            if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
             {
                 Vector512<T> nanMask = IsNaN(result);
                 if (nanMask != Vector512<T>.Zero)
@@ -654,7 +689,7 @@ private static int IndexOfMinMaxVectorized512Size2<T, TOperator>(ReadOnlySpan<T>
                 }
 
                 // Quick return if possible.
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
                 {
                     Vector512<T> nanMask = IsNaN(current);
                     if (nanMask != Vector512<T>.Zero)
@@ -678,8 +713,12 @@ private static int IndexOfMinMaxVectorized512Size2<T, TOperator>(ReadOnlySpan<T>
             {
                 // 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());
+                if (!TOperator.ShouldEarlyExitOnNan && T.IsNaN(aggResult))
+                {
+                    return -1;
+                }
 
+                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());
@@ -695,7 +734,7 @@ private static int IndexOfMinMaxVectorized512Size1<T, TOperator>(ReadOnlySpan<T>
 
             // Initialize result by reading first vector and quick return if possible.
             Vector512<T> result = Vector512.Create(x);
-            if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+            if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
             {
                 Vector512<T> nanMask = IsNaN(result);
                 if (nanMask != Vector512<T>.Zero)
@@ -731,7 +770,7 @@ private static int IndexOfMinMaxVectorized512Size1<T, TOperator>(ReadOnlySpan<T>
                 }
 
                 // Quick return if possible.
-                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                if (TOperator.ShouldEarlyExitOnNan && (typeof(T) == typeof(float) || typeof(T) == typeof(double)))
                 {
                     Vector512<T> nanMask = IsNaN(current);
                     if (nanMask != Vector512<T>.Zero)
@@ -761,8 +800,12 @@ private static int IndexOfMinMaxVectorized512Size1<T, TOperator>(ReadOnlySpan<T>
             {
                 // 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());
+                if (!TOperator.ShouldEarlyExitOnNan && T.IsNaN(aggResult))
+                {
+                    return -1;
+                }
 
+                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);
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 7ea6f2f349a797..858986c5503d21 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
@@ -29,6 +29,7 @@ public static int IndexOfMax<T>(ReadOnlySpan<T> x)
         /// <summary>Returns the index of MathF.Max(x, y)</summary>
         internal readonly struct IndexOfMaxOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
         {
+            public static bool ShouldEarlyExitOnNan => true;
             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);
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 5ca77310c5fa3d..aa303fc09b5774 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
@@ -28,6 +28,7 @@ public static int IndexOfMaxMagnitude<T>(ReadOnlySpan<T> x)
 
         internal readonly struct IndexOfMaxMagnitudeOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
         {
+            public static bool ShouldEarlyExitOnNan => true;
             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);
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 135ca0ac294cc6..6bb77616b4da6d 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
@@ -28,6 +28,7 @@ public static int IndexOfMin<T>(ReadOnlySpan<T> x)
         /// <summary>Returns the index of MathF.Min(x, y)</summary>
         internal readonly struct IndexOfMinOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
         {
+            public static bool ShouldEarlyExitOnNan => true;
             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);
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 437c9537e6962e..e13a5dd1915e38 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
@@ -28,6 +28,7 @@ public static int IndexOfMinMagnitude<T>(ReadOnlySpan<T> x)
 
         internal readonly struct IndexOfMinMagnitudeOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
         {
+            public static bool ShouldEarlyExitOnNan => true;
             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);

From dc34d4da0b1fbcc9d38cf735e458ae5633c77c4d Mon Sep 17 00:00:00 2001
From: Linus Hamlin <linus.hamlin@soderbergpartners.se>
Date: Thu, 18 Jun 2026 16:34:27 +0200
Subject: [PATCH 2/3] Add new methods

---
 .../ref/System.Numerics.Tensors.netcore.cs    |   4 +
 .../src/System.Numerics.Tensors.csproj        |   4 +
 ...sorPrimitives.IndexOfMaxMagnitudeNumber.cs | 152 ++++++++++++++++++
 .../TensorPrimitives.IndexOfMaxNumber.cs      | 104 ++++++++++++
 ...sorPrimitives.IndexOfMinMagnitudeNumber.cs | 149 +++++++++++++++++
 .../TensorPrimitives.IndexOfMinNumber.cs      | 105 ++++++++++++
 6 files changed, 518 insertions(+)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxMagnitudeNumber.cs
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxNumber.cs
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinMagnitudeNumber.cs
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinNumber.cs

diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 920fddf76ec9f4..d8ce86e5720ce7 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -989,9 +989,13 @@ public static void Ieee754Remainder<T>(System.ReadOnlySpan<T> x, T y, System.Spa
         public static void Ieee754Remainder<T>(T x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
         public static void ILogB<T>(System.ReadOnlySpan<T> x, System.Span<int> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
         public static void Increment<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IIncrementOperators<T> { }
+        public static int IndexOfMaxMagnitudeNumber<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
         public static int IndexOfMaxMagnitude<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
+        public static int IndexOfMaxNumber<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
         public static int IndexOfMax<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
+        public static int IndexOfMinMagnitudeNumber<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
         public static int IndexOfMinMagnitude<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
+        public static int IndexOfMinNumber<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
         public static int IndexOfMin<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
         public static bool IsCanonicalAll<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumberBase<T> { throw null; }
         public static bool IsCanonicalAny<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumberBase<T> { throw null; }
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index ca14c969a3494d..c5c90cf7e47796 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -111,8 +111,12 @@
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Increment.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMax.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMaxMagnitude.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMaxMagnitudeNumber.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMaxNumber.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMin.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMinMagnitude.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMinMagnitudeNumber.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.IndexOfMinNumber.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.IsCanonical.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.IsComplexNumber.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.IsEvenInteger.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxMagnitudeNumber.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxMagnitudeNumber.cs
new file mode 100644
index 00000000000000..58d2a1310e75d7
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxMagnitudeNumber.cs
@@ -0,0 +1,152 @@
+// 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.Intrinsics;
+using static System.Numerics.Tensors.TensorOperation;
+
+namespace System.Numerics.Tensors
+{
+    public static partial class TensorPrimitives
+    {
+        /// <summary>Searches for the index of the non-NaN number with the largest magnitude in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The index of the element in <paramref name="x"/> with the largest magnitude (absolute value), or -1 if <paramref name="x"/> is empty or only contain NaN-values.</returns>
+        /// <remarks>
+        /// <para>
+        /// The determination of the maximum magnitude matches the IEEE 754:2019 `maximumMagnitudeNumber` function. NaN-values are ignored.
+        /// If two values have the same magnitude and one is positive and the other is negative, the positive value is considered to have the larger magnitude.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static int IndexOfMaxMagnitudeNumber<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            IndexOfMinMaxCore<T, IndexOfMaxMagnitudeNumberOperator<T>>(x);
+
+        internal readonly struct IndexOfMaxMagnitudeNumberOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
+        {
+            public static bool ShouldEarlyExitOnNan => false;
+            public static T Aggregate(Vector128<T> x) => HorizontalAggregate<T, MaxMagnitudeNumberOperator<T>>(x);
+            public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MaxMagnitudeNumberOperator<T>>(x);
+            public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MaxMagnitudeNumberOperator<T>>(x);
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static bool Compare(T x, T y)
+            {
+                if (T.IsNaN(x))
+                {
+                    return false;
+                }
+                else if (T.IsNaN(y))
+                {
+                    return true;
+                }
+
+                // Don't use T.Abs since it can throw OverflowException.
+                T result = T.MaxMagnitude(x, y);
+                if (result == x)
+                {
+                    if (result == y)
+                    {
+                        // x and y are equal in magnitude
+                        return T.IsPositive(x) && T.IsNegative(y);
+                    }
+                    else
+                    {
+                        // x == result && y != result means x has larger magnitude than y.
+                        return true;
+                    }
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector128<T> Compare(Vector128<T> x, Vector128<T> y)
+            {
+                Vector128<T> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector128<T> equalResult = Vector128.IsPositive(x) & Vector128.IsNegative(y);
+                    Vector128<T> notNanResult = Vector128.GreaterThan(xMag, yMag) | (Vector128.Equals(xMag, yMag) & equalResult);
+                    return notNanResult | Vector128.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else if (typeof(T) == typeof(sbyte)
+                    || typeof(T) == typeof(short)
+                    || typeof(T) == typeof(int)
+                    || typeof(T) == typeof(long)
+                    || typeof(T) == typeof(nint))
+                {
+                    // Consider overflows (when IsNegative(Abs(x))) from Abs(MinValue) which implies maximum magnitude.
+                    Vector128<T> equalResult = Vector128.IsPositive(x) & Vector128.IsNegative(y);
+                    Vector128<T> nonOverflowResult = Vector128.GreaterThan(xMag, yMag) | (Vector128.Equals(xMag, yMag) & equalResult);
+                    return Vector128.AndNot(nonOverflowResult | Vector128.IsNegative(xMag), Vector128.IsNegative(yMag));
+                }
+                else
+                {
+                    return Vector128.GreaterThan(xMag, yMag);
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y)
+            {
+                Vector256<T> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector256<T> equalResult = Vector256.IsPositive(x) & Vector256.IsNegative(y);
+                    Vector256<T> notNanResult = Vector256.GreaterThan(xMag, yMag) | (Vector256.Equals(xMag, yMag) & equalResult);
+                    return notNanResult | Vector256.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else if (typeof(T) == typeof(sbyte)
+                    || typeof(T) == typeof(short)
+                    || typeof(T) == typeof(int)
+                    || typeof(T) == typeof(long)
+                    || typeof(T) == typeof(nint))
+                {
+                    // Consider overflows (when IsNegative(Abs(x))) from Abs(MinValue) which implies maximum magnitude.
+                    Vector256<T> equalResult = Vector256.IsPositive(x) & Vector256.IsNegative(y);
+                    Vector256<T> nonOverflowResult = Vector256.GreaterThan(xMag, yMag) | (Vector256.Equals(xMag, yMag) & equalResult);
+                    return Vector256.AndNot(nonOverflowResult | Vector256.IsNegative(xMag), Vector256.IsNegative(yMag));
+                }
+                else
+                {
+                    return Vector256.GreaterThan(xMag, yMag);
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y)
+            {
+                Vector512<T> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector512<T> equalResult = Vector512.IsPositive(x) & Vector512.IsNegative(y);
+                    Vector512<T> notNanResult = Vector512.GreaterThan(xMag, yMag) | (Vector512.Equals(xMag, yMag) & equalResult);
+                    return notNanResult | Vector512.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else if (typeof(T) == typeof(sbyte)
+                    || typeof(T) == typeof(short)
+                    || typeof(T) == typeof(int)
+                    || typeof(T) == typeof(long)
+                    || typeof(T) == typeof(nint))
+                {
+                    // Consider overflows (when IsNegative(Abs(x))) from Abs(MinValue) which implies maximum magnitude.
+                    Vector512<T> equalResult = Vector512.IsPositive(x) & Vector512.IsNegative(y);
+                    Vector512<T> nonOverflowResult = Vector512.GreaterThan(xMag, yMag) | (Vector512.Equals(xMag, yMag) & equalResult);
+                    return Vector512.AndNot(nonOverflowResult | Vector512.IsNegative(xMag), Vector512.IsNegative(yMag));
+                }
+                else
+                {
+                    return Vector512.GreaterThan(xMag, yMag);
+                }
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxNumber.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxNumber.cs
new file mode 100644
index 00000000000000..75c02577db69d7
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMaxNumber.cs
@@ -0,0 +1,104 @@
+// 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.Intrinsics;
+
+namespace System.Numerics.Tensors
+{
+    public static partial class TensorPrimitives
+    {
+        /// <summary>Searches for the index of the largest non-NaN number in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The index of the maximum element in <paramref name="x"/>, or -1 if <paramref name="x"/> is empty or only contain NaN-values.</returns>
+        /// <remarks>
+        /// <para>
+        /// The determination of the maximum element matches the IEEE 754:2019 `maximumNumber` function. NaN-values are ignored.
+        /// Positive 0 is considered greater than negative 0.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static int IndexOfMaxNumber<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            IndexOfMinMaxCore<T, IndexOfMaxNumberOperator<T>>(x);
+
+        internal readonly struct IndexOfMaxNumberOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
+        {
+            public static bool ShouldEarlyExitOnNan => false;
+            public static T Aggregate(Vector128<T> x) => HorizontalAggregate<T, MaxNumberOperator<T>>(x);
+            public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MaxNumberOperator<T>>(x);
+            public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MaxNumberOperator<T>>(x);
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static bool Compare(T x, T y)
+            {
+                if (T.IsNaN(x))
+                {
+                    return false;
+                }
+                else if (T.IsNaN(y))
+                {
+                    return true;
+                }
+
+                if (x == y)
+                {
+                    return T.IsPositive(x) && T.IsNegative(y);
+                }
+                else
+                {
+                    return x > y;
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector128<T> Compare(Vector128<T> x, Vector128<T> y)
+            {
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector128<T> equalResult = Vector128.IsPositive(x) & Vector128.IsNegative(y);
+                    Vector128<T> notNanResult = Vector128.GreaterThan(x, y) | (Vector128.Equals(x, y) & equalResult);
+                    return notNanResult | Vector128.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else
+                {
+                    return Vector128.GreaterThan(x, y);
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y)
+            {
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector256<T> equalResult = Vector256.IsPositive(x) & Vector256.IsNegative(y);
+                    Vector256<T> notNanResult = Vector256.GreaterThan(x, y) | (Vector256.Equals(x, y) & equalResult);
+                    return notNanResult | Vector256.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else
+                {
+                    return Vector256.GreaterThan(x, y);
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y)
+            {
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector512<T> equalResult = Vector512.IsPositive(x) & Vector512.IsNegative(y);
+                    Vector512<T> notNanResult = Vector512.GreaterThan(x, y) | (Vector512.Equals(x, y) & equalResult);
+                    return notNanResult | Vector512.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else
+                {
+                    return Vector512.GreaterThan(x, y);
+                }
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinMagnitudeNumber.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinMagnitudeNumber.cs
new file mode 100644
index 00000000000000..10e55c2cc0552a
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinMagnitudeNumber.cs
@@ -0,0 +1,149 @@
+// 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.Intrinsics;
+using static System.Numerics.Tensors.TensorOperation;
+
+namespace System.Numerics.Tensors
+{
+    public static partial class TensorPrimitives
+    {
+        /// <summary>Searches for the index of the non-NaN number with the smallest magnitude in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The index of the element in <paramref name="x"/> with the smallest magnitude (absolute value), or -1 if <paramref name="x"/> is empty or only contain NaN-values.</returns>
+        /// <remarks>
+        /// <para>
+        /// The determination of the minimum magnitude matches the IEEE 754:2019 `minimumMagnitudeNumber` function. NaN-values are ignored.
+        /// If two values have the same magnitude and one is positive and the other is negative, the negative value is considered to have the smaller magnitude.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static int IndexOfMinMagnitudeNumber<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            IndexOfMinMaxCore<T, IndexOfMinMagnitudeNumberOperator<T>>(x);
+
+        internal readonly struct IndexOfMinMagnitudeNumberOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
+        {
+            public static bool ShouldEarlyExitOnNan => false;
+            public static T Aggregate(Vector128<T> x) => HorizontalAggregate<T, MinMagnitudeNumberOperator<T>>(x);
+            public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MinMagnitudeNumberOperator<T>>(x);
+            public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MinMagnitudeNumberOperator<T>>(x);
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static bool Compare(T x, T y)
+            {
+                if (T.IsNaN(x))
+                {
+                    return false;
+                }
+                else if (T.IsNaN(y))
+                {
+                    return true;
+                }
+
+                // Don't use T.Abs since it can throw OverflowException.
+                T result = T.MinMagnitude(x, y);
+                if (result == x)
+                {
+                    if (result == y)
+                    {
+                        // x and y are equal in magnitude
+                        return T.IsNegative(x) && T.IsPositive(y);
+                    }
+                    else
+                    {
+                        // x == result && y != result means x has lesser magnitude than y.
+                        return true;
+                    }
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector128<T> Compare(Vector128<T> x, Vector128<T> y)
+            {
+                Vector128<T> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector128<T> equalResult = Vector128.IsNegative(x) & Vector128.IsPositive(y);
+                    Vector128<T> notNanResult = Vector128.LessThan(xMag, yMag) | (Vector128.Equals(xMag, yMag) & equalResult);
+                    return notNanResult | Vector128.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else if (typeof(T) == typeof(sbyte)
+                    || typeof(T) == typeof(short)
+                    || typeof(T) == typeof(int)
+                    || typeof(T) == typeof(long)
+                    || typeof(T) == typeof(nint))
+                {
+                    Vector128<T> equalResult = Vector128.IsNegative(x) & Vector128.IsPositive(y);
+                    Vector128<T> nonOverflowResult = Vector128.LessThan(xMag, yMag) | (Vector128.Equals(xMag, yMag) & equalResult);
+                    return Vector128.AndNot(nonOverflowResult | Vector128.IsNegative(yMag), Vector128.IsNegative(xMag));
+                }
+                else
+                {
+                    return Vector128.LessThan(xMag, yMag);
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y)
+            {
+                Vector256<T> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector256<T> equalResult = Vector256.IsNegative(x) & Vector256.IsPositive(y);
+                    Vector256<T> notNanResult = Vector256.LessThan(xMag, yMag) | (Vector256.Equals(xMag, yMag) & equalResult);
+                    return notNanResult | Vector256.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else if (typeof(T) == typeof(sbyte)
+                    || typeof(T) == typeof(short)
+                    || typeof(T) == typeof(int)
+                    || typeof(T) == typeof(long)
+                    || typeof(T) == typeof(nint))
+                {
+                    Vector256<T> equalResult = Vector256.IsNegative(x) & Vector256.IsPositive(y);
+                    Vector256<T> nonOverflowResult = Vector256.LessThan(xMag, yMag) | (Vector256.Equals(xMag, yMag) & equalResult);
+                    return Vector256.AndNot(nonOverflowResult | Vector256.IsNegative(yMag), Vector256.IsNegative(xMag));
+                }
+                else
+                {
+                    return Vector256.LessThan(xMag, yMag);
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y)
+            {
+                Vector512<T> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector512<T> equalResult = Vector512.IsNegative(x) & Vector512.IsPositive(y);
+                    Vector512<T> notNanResult = Vector512.LessThan(xMag, yMag) | (Vector512.Equals(xMag, yMag) & equalResult);
+                    return notNanResult | Vector512.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else if (typeof(T) == typeof(sbyte)
+                    || typeof(T) == typeof(short)
+                    || typeof(T) == typeof(int)
+                    || typeof(T) == typeof(long)
+                    || typeof(T) == typeof(nint))
+                {
+                    Vector512<T> equalResult = Vector512.IsNegative(x) & Vector512.IsPositive(y);
+                    Vector512<T> nonOverflowResult = Vector512.LessThan(xMag, yMag) | (Vector512.Equals(xMag, yMag) & equalResult);
+                    return Vector512.AndNot(nonOverflowResult | Vector512.IsNegative(yMag), Vector512.IsNegative(xMag));
+                }
+                else
+                {
+                    return Vector512.LessThan(xMag, yMag);
+                }
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinNumber.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinNumber.cs
new file mode 100644
index 00000000000000..e4957382751cd4
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.IndexOfMinNumber.cs
@@ -0,0 +1,105 @@
+// 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.Intrinsics;
+using static System.Numerics.Tensors.TensorOperation;
+
+namespace System.Numerics.Tensors
+{
+    public static partial class TensorPrimitives
+    {
+        /// <summary>Searches for the index of the smallest non-NaN number in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The index of the minimum element in <paramref name="x"/>, or -1 if <paramref name="x"/> is empty or only contain NaN-values.</returns>
+        /// <remarks>
+        /// <para>
+        /// The determination of the minimum element matches the IEEE 754:2019 `minimumNumber` function. NaN-values are ignored.
+        /// Negative 0 is considered smaller than positive 0.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static int IndexOfMinNumber<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            IndexOfMinMaxCore<T, IndexOfMinNumberOperator<T>>(x);
+
+        internal readonly struct IndexOfMinNumberOperator<T> : IIndexOfMinMaxOperator<T> where T : INumber<T>
+        {
+            public static bool ShouldEarlyExitOnNan => false;
+            public static T Aggregate(Vector128<T> x) => HorizontalAggregate<T, MinNumberOperator<T>>(x);
+            public static T Aggregate(Vector256<T> x) => HorizontalAggregate<T, MinNumberOperator<T>>(x);
+            public static T Aggregate(Vector512<T> x) => HorizontalAggregate<T, MinNumberOperator<T>>(x);
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static bool Compare(T x, T y)
+            {
+                if (T.IsNaN(x))
+                {
+                    return false;
+                }
+                else if (T.IsNaN(y))
+                {
+                    return true;
+                }
+
+                if (x == y)
+                {
+                    return T.IsNegative(x) && T.IsPositive(y);
+                }
+                else
+                {
+                    return x < y;
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector128<T> Compare(Vector128<T> x, Vector128<T> y)
+            {
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector128<T> equalResult = Vector128.IsNegative(x) & Vector128.IsPositive(y);
+                    Vector128<T> notNanResult = Vector128.LessThan(x, y) | (Vector128.Equals(x, y) & equalResult);
+                    return notNanResult | Vector128.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else
+                {
+                    return Vector128.LessThan(x, y);
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector256<T> Compare(Vector256<T> x, Vector256<T> y)
+            {
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector256<T> equalResult = Vector256.IsNegative(x) & Vector256.IsPositive(y);
+                    Vector256<T> notNanResult = Vector256.LessThan(x, y) | (Vector256.Equals(x, y) & equalResult);
+                    return notNanResult | Vector256.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else
+                {
+                    return Vector256.LessThan(x, y);
+                }
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector512<T> Compare(Vector512<T> x, Vector512<T> y)
+            {
+                if (typeof(T) == typeof(double) || typeof(T) == typeof(float))
+                {
+                    Vector512<T> equalResult = Vector512.IsNegative(x) & Vector512.IsPositive(y);
+                    Vector512<T> notNanResult = Vector512.LessThan(x, y) | (Vector512.Equals(x, y) & equalResult);
+                    return notNanResult | Vector512.IsNaN(y); // notNanResult will be false if x is NaN
+                }
+                else
+                {
+                    return Vector512.LessThan(x, y);
+                }
+            }
+        }
+    }
+}

From eaf0ef36a5695a456b5d02700d4398c06def3518 Mon Sep 17 00:00:00 2001
From: Linus Hamlin <linus.hamlin@soderbergpartners.se>
Date: Thu, 18 Jun 2026 16:34:35 +0200
Subject: [PATCH 3/3] Add unit tests

---
 .../tests/TensorPrimitives.Generic.cs         | 377 +++++++++++++++++-
 .../tests/TensorPrimitivesTests.cs            |   3 +
 2 files changed, 379 insertions(+), 1 deletion(-)

diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
index f9ed5e03bb1869..031ebc69753184 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
@@ -2725,7 +2725,8 @@ public unsafe abstract class GenericNumberTensorPrimitivesTests<T> : TensorPrimi
         protected override T SumOfSquares(ReadOnlySpan<T> x) => TensorPrimitives.SumOfSquares(x);
 
         protected override T ConvertFromSingle(float f) => T.CreateTruncating(f);
-        protected override bool IsFloatingPoint => typeof(T) == typeof(Half) || base.IsFloatingPoint;
+        protected override bool IsFloatingPoint => typeof(T) == typeof(NFloat) || typeof(T) == typeof(Half) || base.IsFloatingPoint;
+        protected override bool IsUnsignedInteger => typeof(T) == typeof(UInt128) || typeof(T) == typeof(nuint) || base.IsUnsignedInteger;
 
         protected override T NextRandom()
         {
@@ -2856,6 +2857,380 @@ public void ScalarSpanDestination_ThrowsForOverlappingInputsWithOutputs(ScalarSp
         }
         #endregion
 
+        #region IndexOfMaxNumber
+        [Fact]
+        public void IndexOfMaxNumber_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, TensorPrimitives.IndexOfMaxNumber(ReadOnlySpan<T>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMaxNumber_ReturnsNegative1OnOnlyNaNs()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                x.Span.Fill(NaN);
+                Assert.Equal(-1, TensorPrimitives.IndexOfMaxNumber(x.Span));
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxNumber_AllLengths()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = Enumerable.Max(MemoryMarshal.ToEnumerable<T>(x.Memory));
+                    int actual = TensorPrimitives.IndexOfMaxNumber(x.Span);
+                    Assert.True(actual == expected || (actual < expected && x[actual].Equals(x[expected])), $"{tensorLength} {actual} {expected}     {string.Join(",", MemoryMarshal.ToEnumerable<T>(x.Memory))}");
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxNumber_NaNsNotReturned()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateTensor(tensorLength);
+                    x.Span.Fill(NaN);
+                    x[expected] = One;
+                    x[tensorLength - 1] = One;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMaxNumber(x.Span));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxNumber_Negative0LesserThanPositive0()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateTensor(tensorLength);
+                    x.Span.Fill(NegativeZero);
+                    x[expected] = Zero;
+                    x[tensorLength - 1] = Zero;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMaxNumber(x.Span));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxNumber_IndexAboveMaxValue()
+        {
+            var size = IndexOfSizeExceedingMaxValue();
+            if (size == null) return;
+
+            using BoundedMemory<T> x = CreateTensor(size.Value);
+            x.Span.Fill(One);
+            x.Span[size.Value - 1] = ConvertFromSingle(2);
+            Assert.Equal(size.Value - 1, TensorPrimitives.IndexOfMaxNumber(x.Span));
+        }
+        #endregion
+
+        #region IndexOfMaxMagnitudeNumber
+        [Fact]
+        public void IndexOfMaxMagnitudeNumber_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, TensorPrimitives.IndexOfMaxMagnitudeNumber(ReadOnlySpan<T>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMaxMagnitudeNumber_ReturnsNegative1OnOnlyNaNs()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                x.Span.Fill(NaN);
+                Assert.Equal(-1, TensorPrimitives.IndexOfMaxMagnitudeNumber(x.Span));
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxMagnitudeNumber_AllLengths()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+
+                    T max = x[0];
+                    for (int i = 0; i < x.Length; i++)
+                    {
+                        max = T.MaxMagnitudeNumber(max, x[i]);
+                    }
+                    x[expected] = max;
+
+                    int actual = TensorPrimitives.IndexOfMaxMagnitudeNumber(x.Span);
+
+                    if (actual != expected)
+                    {
+                        Assert.True(actual < expected || Comparer<T>.Default.Compare(x[actual], x[expected]) > 0, $"{tensorLength} {actual} {expected}     {string.Join(",", MemoryMarshal.ToEnumerable<T>(x.Memory))}");
+                        if (IsFloatingPoint)
+                        {
+                            AssertEqualTolerance(x[expected], x[actual], Zero);
+                        }
+                        else
+                        {
+                            Assert.Equal(x[expected], x[actual]);
+                        }
+                    }
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxMagnitudeNumber_NaNsNotReturned()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateTensor(tensorLength);
+                    x.Span.Fill(NaN);
+                    x[expected] = One;
+                    x[tensorLength - 1] = One;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMaxMagnitudeNumber(x.Span));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxMagnitudeNumber_Negative1LesserThanPositive1()
+        {
+            if (IsUnsignedInteger) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateTensor(tensorLength);
+                    x.Span.Fill(NegativeOne);
+                    x[expected] = One;
+                    x[tensorLength - 1] = One;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMaxMagnitudeNumber(x.Span));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxMagnitudeNumber_IndexAboveMaxValue()
+        {
+            var size = IndexOfSizeExceedingMaxValue();
+            if (size == null) return;
+
+            using BoundedMemory<T> x = CreateTensor(size.Value);
+            x.Span.Fill(One);
+            x.Span[size.Value - 1] = ConvertFromSingle(2);
+            Assert.Equal(size.Value - 1, TensorPrimitives.IndexOfMaxMagnitudeNumber(x.Span));
+        }
+        #endregion
+
+        #region IndexOfMinNumber
+        [Fact]
+        public void IndexOfMinNumber_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, TensorPrimitives.IndexOfMinNumber(ReadOnlySpan<T>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMinNumber_ReturnsNegative1OnOnlyNaNs()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                x.Span.Fill(NaN);
+                Assert.Equal(-1, TensorPrimitives.IndexOfMinNumber(x.Span));
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinNumber_AllLengths()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = Enumerable.Min(MemoryMarshal.ToEnumerable<T>(x.Memory));
+                    int actual = TensorPrimitives.IndexOfMinNumber(x.Span);
+                    Assert.True(actual == expected || (actual < expected && x[actual].Equals(x[expected])), $"{tensorLength} {actual} {expected}     {string.Join(",", MemoryMarshal.ToEnumerable<T>(x.Memory))}");
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinNumber_NaNsNotReturned()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateTensor(tensorLength);
+                    x.Span.Fill(NaN);
+                    x[expected] = One;
+                    x[tensorLength - 1] = One;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMinNumber(x.Span));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinNumber_Negative0LesserThanPositive0()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateTensor(tensorLength);
+                    x.Span.Fill(Zero);
+                    x[expected] = NegativeZero;
+                    x[tensorLength - 1] = NegativeZero;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMinNumber(x.Span));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinNumber_IndexAboveMaxValue()
+        {
+            var size = IndexOfSizeExceedingMaxValue();
+            if (size == null) return;
+
+            using BoundedMemory<T> x = CreateTensor(size.Value);
+            x.Span.Fill(ConvertFromSingle(2));
+            x.Span[size.Value - 1] = One;
+            Assert.Equal(size.Value - 1, TensorPrimitives.IndexOfMinNumber(x.Span));
+        }
+        #endregion
+
+        #region IndexOfMinMagnitudeNumber
+        [Fact]
+        public void IndexOfMinMagnitudeNumber_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, TensorPrimitives.IndexOfMinMagnitudeNumber(ReadOnlySpan<T>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMinMagnitudeNumber_ReturnsNegative1OnOnlyNaNs()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                x.Span.Fill(NaN);
+                Assert.Equal(-1, TensorPrimitives.IndexOfMinMagnitudeNumber(x.Span));
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinMagnitudeNumber_AllLengths()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+
+                    T min = x[0];
+                    for (int i = 0; i < x.Length; i++)
+                    {
+                        min = T.MinMagnitudeNumber(min, x[i]);
+                    }
+                    x[expected] = min;
+
+                    int actual = TensorPrimitives.IndexOfMinMagnitudeNumber(x.Span);
+
+                    if (actual != expected)
+                    {
+                        Assert.True(actual < expected || Comparer<T>.Default.Compare(x[actual], x[expected]) > 0, $"{tensorLength} {actual} {expected}     {string.Join(",", MemoryMarshal.ToEnumerable<T>(x.Memory))}");
+                        if (IsFloatingPoint)
+                        {
+                            AssertEqualTolerance(x[expected], x[actual], Zero);
+                        }
+                        else
+                        {
+                            Assert.Equal(x[expected], x[actual]);
+                        }
+                    }
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinMagnitudeNumber_NaNsNotReturned()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateTensor(tensorLength);
+                    x.Span.Fill(NaN);
+                    x[expected] = One;
+                    x[tensorLength - 1] = One;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMinMagnitudeNumber(x.Span));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinMagnitudeNumber_Negative1LesserThanPositive1()
+        {
+            if (IsUnsignedInteger) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateTensor(tensorLength);
+                    x.Span.Fill(One);
+                    x[expected] = NegativeOne;
+                    x[tensorLength - 1] = NegativeOne;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMinMagnitudeNumber(x.Span));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinMagnitudeNumber_IndexAboveMaxValue()
+        {
+            var size = IndexOfSizeExceedingMaxValue();
+            if (size == null) return;
+
+            using BoundedMemory<T> x = CreateTensor(size.Value);
+            x.Span.Fill(ConvertFromSingle(2));
+            x.Span[size.Value - 1] = One;
+            Assert.Equal(size.Value - 1, TensorPrimitives.IndexOfMinMagnitudeNumber(x.Span));
+        }
+        #endregion
+
         #region IsXx
         public static IEnumerable<object[]> SpanDestinationIsFunctionsToTest()
         {
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
index 55dc2be94487d9..8407232ed1bf59 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
@@ -105,6 +105,9 @@ public abstract class TensorPrimitivesTests<T> where T : unmanaged, IEquatable<T
         public delegate bool SpanIsAllAnyDelegate(ReadOnlySpan<T> x);
 
         protected virtual bool IsFloatingPoint => typeof(T) == typeof(float) || typeof(T) == typeof(double);
+        protected virtual bool IsUnsignedInteger =>
+            typeof(T) == typeof(byte) || typeof(T) == typeof(ushort) || typeof(T) == typeof(uint) ||
+            typeof(T) == typeof(ulong) || typeof(T) == typeof(char);
 
         protected virtual int? IndexOfSizeExceedingMaxValue() =>
             (typeof(T) == typeof(byte) || typeof(T) == typeof(sbyte)) ? Helpers.SizeGreaterThanByte :