Add TensorPrimitives.{Max/Min}MagnitudeNumber

src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs

@@ -476,6 +476,9 @@ public static void Log10<T>(System.ReadOnlySpan<T> x, System.Span<T> destination
  public static T MaxMagnitude<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumberBase<T> { throw null; }
  public static void MaxMagnitude<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
  public static void MaxMagnitude<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
+ public static T MaxMagnitudeNumber<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumberBase<T> { throw null; }
+ public static void MaxMagnitudeNumber<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
+ public static void MaxMagnitudeNumber<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
  public static T Max<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
  public static void Max<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.INumber<T> { }
  public static void Max<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.INumber<T> { }
@@ -485,6 +488,9 @@ public static void MaxNumber<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> de
  public static T MinMagnitude<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumberBase<T> { throw null; }
  public static void MinMagnitude<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
  public static void MinMagnitude<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
+ public static T MinMagnitudeNumber<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumberBase<T> { throw null; }
+ public static void MinMagnitudeNumber<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
+ public static void MinMagnitudeNumber<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
  public static T Min<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
  public static void Min<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.INumber<T> { }
  public static void Min<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.INumber<T> { }

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.MaxMagnitudeNumber.cs

@@ -9,6 +9,75 @@ namespace System.Numerics.Tensors
 {
  public static partial class TensorPrimitives
  {
+ /// <summary>Searches for the number with the largest magnitude in the specified tensor.</summary>
+ /// <param name="x">The tensor, represented as a span.</param>
+ /// <returns>The element in <paramref name="x"/> with the largest magnitude (absolute value).</returns>
+ /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+ /// <remarks>
+ /// <para>
+ /// The determination of the maximum magnitude matches the IEEE 754:2019 `maximumMagnitudeNumber` function.
+ /// 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 T MaxMagnitudeNumber<T>(ReadOnlySpan<T> x)
+ where T : INumberBase<T> =>
+ MinMaxCore<T, MaxMagnitudeNumberOperator<T>>(x);
+
+ /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+ /// <param name="x">The first tensor, represented as a span.</param>
+ /// <param name="y">The second tensor, represented as a span.</param>
+ /// <param name="destination">The destination tensor, represented as a span.</param>
+ /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+ /// <exception cref="ArgumentException">Destination is too short.</exception>
+ /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+ /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+ /// <remarks>
+ /// <para>
+ /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.MaxMagnitudeNumber(<paramref name="x" />[i], <paramref name="y" />[i])</c>.
+ /// </para>
+ /// <para>
+ /// The determination of the maximum magnitude matches the IEEE 754:2019 `maximumMagnitudeNumber` function.
+ /// If the 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 void MaxMagnitudeNumber<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+ where T : INumberBase<T> =>
+ InvokeSpanSpanIntoSpan<T, MaxMagnitudeNumberOperator<T>>(x, y, destination);
+
+ /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+ /// <param name="x">The first tensor, represented as a span.</param>
+ /// <param name="y">The second tensor, represented as a scalar.</param>
+ /// <param name="destination">The destination tensor, represented as a span.</param>
+ /// <exception cref="ArgumentException">Destination is too short.</exception>
+ /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+ /// <remarks>
+ /// <para>
+ /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.MaxMagnitudeNumber(<paramref name="x" />[i], <paramref name="y" />)</c>.
+ /// </para>
+ /// <para>
+ /// The determination of the maximum magnitude matches the IEEE 754:2019 `maximumMagnitudeNumber` function.
+ /// If the 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 void MaxMagnitudeNumber<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+ where T : INumberBase<T> =>
+ InvokeSpanScalarIntoSpan<T, MaxMagnitudeNumberOperator<T>>(x, y, destination);
+
  /// <summary>Operator to get x or y based on which has the larger MathF.Abs</summary>
  internal readonly struct MaxMagnitudeNumberOperator<T> : IAggregationOperator<T>
  where T : INumberBase<T>

src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.MinMagnitudeNumber.cs

@@ -9,6 +9,75 @@ namespace System.Numerics.Tensors
 {
  public static partial class TensorPrimitives
  {
+ /// <summary>Searches for the number with the smallest magnitude in the specified tensor.</summary>
+ /// <param name="x">The tensor, represented as a span.</param>
+ /// <returns>The element in <paramref name="x"/> with the smallest magnitude (absolute value).</returns>
+ /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+ /// <remarks>
+ /// <para>
+ /// The determination of the minimum magnitude matches the IEEE 754:2019 `minimumMagnitudeNumber` function.
+ /// 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 T MinMagnitudeNumber<T>(ReadOnlySpan<T> x)
+ where T : INumberBase<T> =>
+ MinMaxCore<T, MinMagnitudeNumberOperator<T>>(x);
+
+ /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
+ /// <param name="x">The first tensor, represented as a span.</param>
+ /// <param name="y">The second tensor, represented as a span.</param>
+ /// <param name="destination">The destination tensor, represented as a span.</param>
+ /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+ /// <exception cref="ArgumentException">Destination is too short.</exception>
+ /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+ /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+ /// <remarks>
+ /// <para>
+ /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.MinMagnitudeNumber(<paramref name="x" />[i], <paramref name="y" />[i])</c>.
+ /// </para>
+ /// <para>
+ /// The determination of the maximum magnitude matches the IEEE 754:2019 `minimumMagnitudeNumber` function.
+ /// If the 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 void MinMagnitudeNumber<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+ where T : INumberBase<T> =>
+ InvokeSpanSpanIntoSpan<T, MinMagnitudeNumberOperator<T>>(x, y, destination);
+
+ /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
+ /// <param name="x">The first tensor, represented as a span.</param>
+ /// <param name="y">The second tensor, represented as a scalar.</param>
+ /// <param name="destination">The destination tensor, represented as a span.</param>
+ /// <exception cref="ArgumentException">Destination is too short.</exception>
+ /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+ /// <remarks>
+ /// <para>
+ /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.MinMagnitudeNumber(<paramref name="x" />[i], <paramref name="y" />)</c>.
+ /// </para>
+ /// <para>
+ /// The determination of the maximum magnitude matches the IEEE 754:2019 `minimumMagnitudeNumber` function.
+ /// If the 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 void MinMagnitudeNumber<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+ where T : INumberBase<T> =>
+ InvokeSpanScalarIntoSpan<T, MinMagnitudeNumberOperator<T>>(x, y, destination);
+
  /// <summary>Operator to get x or y based on which has the smaller MathF.Abs</summary>
  internal readonly struct MinMagnitudeNumberOperator<T> : IAggregationOperator<T>
  where T : INumberBase<T>

src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs

@@ -522,8 +522,14 @@ public static IEnumerable<object[]> SpanSpanDestinationFunctionsToTest()
  yield return Create(TensorPrimitives.Hypot, T.Hypot);
  yield return Create(TensorPrimitives.Ieee754Remainder, T.Ieee754Remainder);
  yield return Create(TensorPrimitives.Log, T.Log);
+ yield return Create(TensorPrimitives.Max, T.Max);
  yield return Create(TensorPrimitives.MaxNumber, T.MaxNumber);
+ yield return Create(TensorPrimitives.MaxMagnitude, T.MaxMagnitude);
+ yield return Create(TensorPrimitives.MaxMagnitudeNumber, T.MaxMagnitudeNumber);
+ yield return Create(TensorPrimitives.Min, T.Min);
  yield return Create(TensorPrimitives.MinNumber, T.MinNumber);
+ yield return Create(TensorPrimitives.MinMagnitude, T.MinMagnitude);
+ yield return Create(TensorPrimitives.MinMagnitudeNumber, T.MinMagnitudeNumber);
  yield return Create(TensorPrimitives.Pow, T.Pow, Helpers.DetermineTolerance<T>(doubleTolerance: 1e-13, floatTolerance: 1e-5f));
 
  static object[] Create(SpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> expectedMethod, T? tolerance = null)
@@ -656,11 +662,13 @@ public static IEnumerable<object[]> SpanScalarDestinationFunctionsToTest()
  yield return Create(TensorPrimitives.Pow, T.Pow, Helpers.DetermineTolerance<T>(doubleTolerance: 1e-13, floatTolerance: 1e-5f));
  yield return Create(TensorPrimitives.Log, T.Log);
  yield return Create(TensorPrimitives.Max, T.Max);
- yield return Create(TensorPrimitives.MaxMagnitude, T.MaxMagnitude);
  yield return Create(TensorPrimitives.MaxNumber, T.MaxNumber);
+ yield return Create(TensorPrimitives.MaxMagnitude, T.MaxMagnitude);
+ yield return Create(TensorPrimitives.MaxMagnitudeNumber, T.MaxMagnitudeNumber);
  yield return Create(TensorPrimitives.Min, T.Min);
- yield return Create(TensorPrimitives.MinMagnitude, T.MinMagnitude);
  yield return Create(TensorPrimitives.MinNumber, T.MinNumber);
+ yield return Create(TensorPrimitives.MinMagnitude, T.MinMagnitude);
+ yield return Create(TensorPrimitives.MinMagnitudeNumber, T.MinMagnitudeNumber);
 
  static object[] Create(SpanScalarDestinationDelegate<T, T, T> tensorPrimitivesMethod, Func<T, T, T> expectedMethod, T? tolerance = null)
  => new object[] { tensorPrimitivesMethod, expectedMethod, tolerance };
@@ -1841,11 +1849,13 @@ public static IEnumerable<object[]> SpanScalarDestinationFunctionsToTest()
  yield return Create(TensorPrimitives.BitwiseAnd, (x, y) => x & y);
  yield return Create(TensorPrimitives.BitwiseOr, (x, y) => x | y);
  yield return Create(TensorPrimitives.Max, T.Max);
- yield return Create(TensorPrimitives.MaxMagnitude, T.MaxMagnitude);
  yield return Create(TensorPrimitives.MaxNumber, T.MaxNumber);
+ yield return Create(TensorPrimitives.MaxMagnitude, T.MaxMagnitude);
+ yield return Create(TensorPrimitives.MaxMagnitudeNumber, T.MaxMagnitudeNumber);
  yield return Create(TensorPrimitives.Min, T.Min);
- yield return Create(TensorPrimitives.MinMagnitude, T.MinMagnitude);
  yield return Create(TensorPrimitives.MinNumber, T.MinNumber);
+ yield return Create(TensorPrimitives.MinMagnitude, T.MinMagnitude);
+ yield return Create(TensorPrimitives.MinMagnitudeNumber, T.MinMagnitudeNumber);
  yield return Create(TensorPrimitives.Xor, (x, y) => x ^ y);
 
  static object[] Create(SpanScalarDestinationDelegate<T, T, T> tensorPrimitivesMethod, Func<T, T, T> expectedMethod)