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 da348aca973905..031ba109ba6b57 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
@@ -9,48 +9,140 @@ namespace System.Numerics.Tensors
     public static partial class TensorPrimitives
     {
         public static void Abs<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
+        public static void Acosh<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IHyperbolicFunctions<T> { }
+        public static void AcosPi<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
+        public static void Acos<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
         public static void AddMultiply<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.ReadOnlySpan<T> multiplier, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
         public static void AddMultiply<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, T multiplier, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
         public static void AddMultiply<T>(System.ReadOnlySpan<T> x, T y, System.ReadOnlySpan<T> multiplier, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
         public static void Add<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { }
         public static void Add<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { }
-        public static void ConvertToHalf(System.ReadOnlySpan<float> source, System.Span<System.Half> destination) { throw null; }
-        public static void ConvertToSingle(System.ReadOnlySpan<System.Half> source, System.Span<float> destination) { throw null; }
+        public static void Asinh<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IHyperbolicFunctions<T> { }
+        public static void AsinPi<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
+        public static void Asin<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
+        public static void Atan2Pi<T>(System.ReadOnlySpan<T> y, System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void Atan2Pi<T>(System.ReadOnlySpan<T> y, T x, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void Atan2Pi<T>(T y, System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void Atan2<T>(System.ReadOnlySpan<T> y, System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void Atan2<T>(System.ReadOnlySpan<T> y, T x, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void Atan2<T>(T y, System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void Atanh<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IHyperbolicFunctions<T> { }
+        public static void AtanPi<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
+        public static void Atan<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
+        public static void BitwiseAnd<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IBitwiseOperators<T, T, T> { }
+        public static void BitwiseAnd<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.IBitwiseOperators<T, T, T> { }
+        public static void BitwiseOr<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IBitwiseOperators<T, T, T> { }
+        public static void BitwiseOr<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.IBitwiseOperators<T, T, T> { }
+        public static void Cbrt<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IRootFunctions<T> { }
+        public static void Ceiling<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPoint<T> { }
+        public static void ConvertToHalf(System.ReadOnlySpan<float> source, System.Span<System.Half> destination) { }
+        public static void ConvertToSingle(System.ReadOnlySpan<System.Half> source, System.Span<float> destination) { }
+        public static void CopySign<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> sign, System.Span<T> destination) where T : System.Numerics.INumber<T> { }
+        public static void CopySign<T>(System.ReadOnlySpan<T> x, T sign, System.Span<T> destination) where T : System.Numerics.INumber<T> { }
+        public static void CosPi<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
+        public static void Cos<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
         public static void Cosh<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IHyperbolicFunctions<T> { }
         public static T CosineSimilarity<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y) where T : System.Numerics.IRootFunctions<T> { throw null; }
+        public static void DegreesToRadians<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
         public static T Distance<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y) where T : System.Numerics.IRootFunctions<T> { throw null; }
         public static void Divide<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IDivisionOperators<T, T, T> { }
         public static void Divide<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.IDivisionOperators<T, T, T> { }
+        public static void Divide<T>(T x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IDivisionOperators<T, T, T> { }
         public static T Dot<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
         public static void Exp<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IExponentialFunctions<T> { }
+        public static void Exp10M1<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IExponentialFunctions<T> { }
+        public static void Exp10<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IExponentialFunctions<T> { }
+        public static void Exp2M1<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IExponentialFunctions<T> { }
+        public static void Exp2<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IExponentialFunctions<T> { }
+        public static void ExpM1<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IExponentialFunctions<T> { }
+        public static void Floor<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPoint<T> { }
+        public static void Hypot<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IRootFunctions<T> { }
+        public static void Ieee754Remainder<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void Ieee754Remainder<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        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 int IndexOfMaxMagnitude<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 IndexOfMinMagnitude<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 void LeadingZeroCount<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IBinaryInteger<T> { }
+        public static void Lerp<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.ReadOnlySpan<T> amount, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void Lerp<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, T amount, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void Lerp<T>(System.ReadOnlySpan<T> x, T y, System.ReadOnlySpan<T> amount, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
         public static void Log2<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ILogarithmicFunctions<T> { }
+        public static void Log2P1<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ILogarithmicFunctions<T> { }
+        public static void LogP1<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ILogarithmicFunctions<T> { }
+        public static void Log<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.ILogarithmicFunctions<T> { }
+        public static void Log<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.ILogarithmicFunctions<T> { }
         public static void Log<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ILogarithmicFunctions<T> { }
+        public static void Log10P1<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ILogarithmicFunctions<T> { }
+        public static void Log10<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ILogarithmicFunctions<T> { }
         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 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> { }
         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 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> { }
         public static void MultiplyAdd<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.ReadOnlySpan<T> addend, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
         public static void MultiplyAdd<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, T addend, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
         public static void MultiplyAdd<T>(System.ReadOnlySpan<T> x, T y, System.ReadOnlySpan<T> addend, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
+        public static void FusedMultiplyAdd<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.ReadOnlySpan<T> addend, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void FusedMultiplyAdd<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, T addend, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void FusedMultiplyAdd<T>(System.ReadOnlySpan<T> x, T y, System.ReadOnlySpan<T> addend, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
         public static void Multiply<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { }
         public static void Multiply<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { }
         public static void Negate<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IUnaryNegationOperators<T, T> { }
         public static T Norm<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.IRootFunctions<T> { throw null; }
+        public static void OnesComplement<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IBitwiseOperators<T, T, T> { }
+        public static void PopCount<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IBinaryInteger<T> { }
+        public static void Pow<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IPowerFunctions<T> { }
+        public static void Pow<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.IPowerFunctions<T> { }
+        public static void Pow<T>(T x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IPowerFunctions<T> { }
         public static T ProductOfDifferences<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y) where T : System.Numerics.ISubtractionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
         public static T ProductOfSums<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
         public static T Product<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
+        public static void RadiansToDegrees<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
+        public static void ReciprocalEstimate<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void ReciprocalSqrtEstimate<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void ReciprocalSqrt<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void Reciprocal<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPoint<T> { }
+        public static void RootN<T>(System.ReadOnlySpan<T> x, int n, System.Span<T> destination) where T : System.Numerics.IRootFunctions<T> { }
+        public static void RotateLeft<T>(System.ReadOnlySpan<T> x, int rotateAmount, System.Span<T> destination) where T : System.Numerics.IBinaryInteger<T> { }
+        public static void RotateRight<T>(System.ReadOnlySpan<T> x, int rotateAmount, System.Span<T> destination) where T : System.Numerics.IBinaryInteger<T> { }
+        public static void Round<T>(System.ReadOnlySpan<T> x, int digits, System.MidpointRounding mode, System.Span<T> destination) where T : System.Numerics.IFloatingPoint<T> { }
+        public static void Round<T>(System.ReadOnlySpan<T> x, int digits, System.Span<T> destination) where T : System.Numerics.IFloatingPoint<T> { }
+        public static void Round<T>(System.ReadOnlySpan<T> x, System.MidpointRounding mode, System.Span<T> destination) where T : System.Numerics.IFloatingPoint<T> { }
+        public static void Round<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPoint<T> { }
+        public static void ScaleB<T>(System.ReadOnlySpan<T> x, int n, System.Span<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { }
+        public static void ShiftLeft<T>(System.ReadOnlySpan<T> x, int shiftAmount, System.Span<T> destination) where T : System.Numerics.IBinaryInteger<T> { }
+        public static void ShiftRightArithmetic<T>(System.ReadOnlySpan<T> x, int shiftAmount, System.Span<T> destination) where T : System.Numerics.IBinaryInteger<T> { }
+        public static void ShiftRightLogical<T>(System.ReadOnlySpan<T> x, int shiftAmount, System.Span<T> destination) where T : System.Numerics.IBinaryInteger<T> { }
         public static void Sigmoid<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IExponentialFunctions<T> { }
+        public static void SinCosPi<T>(System.ReadOnlySpan<T> x, System.Span<T> sinPiDestination, System.Span<T> cosPiDestination) where T : System.Numerics.ITrigonometricFunctions<T> { }
+        public static void SinCos<T>(System.ReadOnlySpan<T> x, System.Span<T> sinDestination, System.Span<T> cosDestination) where T : System.Numerics.ITrigonometricFunctions<T> { }
         public static void Sinh<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IHyperbolicFunctions<T> { }
+        public static void SinPi<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
+        public static void Sin<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
         public static void SoftMax<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IExponentialFunctions<T> { }
+        public static void Sqrt<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IRootFunctions<T> { }
         public static void Subtract<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.ISubtractionOperators<T, T, T> { }
         public static void Subtract<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.ISubtractionOperators<T, T, T> { }
+        public static void Subtract<T>(T x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.ISubtractionOperators<T, T, T> { }
         public static T SumOfMagnitudes<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumberBase<T> { throw null; }
         public static T SumOfSquares<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T>, System.Numerics.IMultiplyOperators<T, T, T> { throw null; }
         public static T Sum<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
         public static void Tanh<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IHyperbolicFunctions<T> { }
+        public static void TanPi<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
+        public static void Tan<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { }
+        public static void TrailingZeroCount<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IBinaryInteger<T> { }
+        public static void Truncate<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IFloatingPoint<T> { }
+        public static void Xor<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IBitwiseOperators<T, T, T> { }
+        public static void Xor<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.IBitwiseOperators<T, T, T> { }
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Single.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Single.cs
index 0ad05d15286d97..7255f7a212bd10 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Single.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Single.cs
@@ -303,7 +303,7 @@ public static void Exp(ReadOnlySpan<float> x, Span<float> destination) =>
         /// </para>
         /// </remarks>
         public static int IndexOfMax(ReadOnlySpan<float> x) =>
-            IndexOfMinMaxCore<IndexOfMaxOperator_Single>(x);
+            IndexOfMinMaxCore<float, IndexOfMaxOperator_Single>(x);
 
         /// <summary>Searches for the index of the single-precision floating-point number with the largest magnitude in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -320,7 +320,7 @@ public static int IndexOfMax(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static int IndexOfMaxMagnitude(ReadOnlySpan<float> x) =>
-            IndexOfMinMaxCore<IndexOfMaxMagnitudeOperator_Single>(x);
+            IndexOfMinMaxCore<float, IndexOfMaxMagnitudeOperator_Single>(x);
 
         /// <summary>Searches for the index of the smallest single-precision floating-point number in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -336,7 +336,7 @@ public static int IndexOfMaxMagnitude(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static int IndexOfMin(ReadOnlySpan<float> x) =>
-            IndexOfMinMaxCore<IndexOfMinOperator_Single>(x);
+            IndexOfMinMaxCore<float, IndexOfMinOperator_Single>(x);
 
         /// <summary>Searches for the index of the single-precision floating-point number with the smallest magnitude in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -353,7 +353,7 @@ public static int IndexOfMin(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static int IndexOfMinMagnitude(ReadOnlySpan<float> x) =>
-            IndexOfMinMaxCore<IndexOfMinMagnitudeOperator_Single>(x);
+            IndexOfMinMaxCore<float, IndexOfMinMagnitudeOperator_Single>(x);
 
         /// <summary>Computes the element-wise natural (base <c>e</c>) logarithm of single-precision floating-point numbers in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Single.netcore.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Single.netcore.cs
index 3747906c5317e6..1148639d48be02 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Single.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Single.netcore.cs
@@ -1,7 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-// This file exists to enable TensorPrimitives.float.cs to be compiled for both
+// This file exists to enable TensorPrimitives.Single.cs to be compiled for both
 // netstandard2.0 and net8.0+ targets. It uses the XX_Single names and the operation
 // methods tied to float, whereas the net8.0+ worker implementations use generic math.
 // This file provides float-bound types and type defs that route one to the other.
@@ -14,6 +14,10 @@
 global using DivideOperator_Single = System.Numerics.Tensors.TensorPrimitives.DivideOperator<float>;
 global using MultiplyOperator_Single = System.Numerics.Tensors.TensorPrimitives.MultiplyOperator<float>;
 global using ExpOperator_Single = System.Numerics.Tensors.TensorPrimitives.ExpOperator<float>;
+global using IndexOfMaxOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMaxOperator<float>;
+global using IndexOfMaxMagnitudeOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMaxMagnitudeOperator<float>;
+global using IndexOfMinOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMinOperator<float>;
+global using IndexOfMinMagnitudeOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMinMagnitudeOperator<float>;
 global using LogOperator_Single = System.Numerics.Tensors.TensorPrimitives.LogOperator<float>;
 global using Log2Operator_Single = System.Numerics.Tensors.TensorPrimitives.Log2Operator<float>;
 global using MaxOperator_Single = System.Numerics.Tensors.TensorPrimitives.MaxOperator<float>;
@@ -33,12 +37,6 @@
 global using SquaredOperator_Single = System.Numerics.Tensors.TensorPrimitives.SquaredOperator<float>;
 global using TanhOperator_Single = System.Numerics.Tensors.TensorPrimitives.TanhOperator<float>;
 
-// TODO: These should be made generic. Their implementations are still currently bound to float.
-global using IndexOfMaxOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMaxOperator;
-global using IndexOfMaxMagnitudeOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMaxMagnitudeOperator;
-global using IndexOfMinOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMinOperator;
-global using IndexOfMinMagnitudeOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMinMagnitudeOperator;
-
 namespace System.Numerics.Tensors
 {
     public static unsafe partial class TensorPrimitives
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.T.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.T.cs
index f9a44e8680123d..fdf8e37fb06e58 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.T.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.T.cs
@@ -1,8 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-// TODO:
-// - Provide generic overloads for the IndexOfMin/Max{Magnitude} methods
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
 namespace System.Numerics.Tensors
 {
     /// <summary>Performs primitive tensor operations over spans of memory.</summary>
@@ -16,7 +17,7 @@ public static partial class TensorPrimitives
         /// <exception cref="OverflowException"><typeparamref name="T"/> is a signed integer type and <paramref name="x"/> contained a value equal to <typeparamref name="T"/>'s minimum value.</exception>
         /// <remarks>
         /// <para>
-        /// This method effectively computes <c><paramref name="destination" />[i] = MathF.Abs(<paramref name="x" />[i])</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Abs(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
         /// The absolute value of a <typeparamref name="T"/> is its numeric value without its sign. For example, the absolute value of both 1.2e-03 and -1.2e03 is 1.2e03.
@@ -30,419 +31,287 @@ public static void Abs<T>(ReadOnlySpan<T> x, Span<T> destination)
             where T : INumberBase<T> =>
             InvokeSpanIntoSpan<T, AbsoluteOperator<T>>(x, destination);
 
-        /// <summary>Computes the element-wise addition of numbers 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>
+        /// <summary>Computes the element-wise angle in radians whose cosine is the specifed number.</summary>
+        /// <param name="x">The 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] = <paramref name="x" />[i] + <paramref name="y" />[i]</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Acos(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
-        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// 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 Add<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T> =>
-            InvokeSpanSpanIntoSpan<T, AddOperator<T>>(x, y, destination);
+        public static void Acos<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, AcosOperator<T>>(x, destination);
 
-        /// <summary>Computes the element-wise addition of numbers 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>
+        /// <summary>Computes the element-wise hyperbolic arc-cosine of the specifed number.</summary>
+        /// <param name="x">The tensor, represented as a span.</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] = <paramref name="x" />[i] + <paramref name="y" /></c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Acosh(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
-        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// 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 Add<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T> =>
-            InvokeSpanScalarIntoSpan<T, AddOperator<T>>(x, y, destination);
+        public static void Acosh<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IHyperbolicFunctions<T> =>
+            InvokeSpanIntoSpan<T, AcoshOperator<T>>(x, destination);
 
-        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for 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="multiplier">The third tensor, represented as a span.</param>
+        /// <summary>Computes the element-wise angle in radians whose cosine is the specifed number and divides the result by Pi.</summary>
+        /// <param name="x">The 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" /> and the length of <paramref name="multiplier" />.</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>
-        /// <exception cref="ArgumentException"><paramref name="multiplier"/> 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] = (<paramref name="x" />[i] + <paramref name="y" />[i]) * <paramref name="multiplier" />[i]</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.AcosPi(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
-        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// 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 AddMultiply<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> multiplier, Span<T> destination)
-            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
-            InvokeSpanSpanSpanIntoSpan<T, AddMultiplyOperator<T>>(x, y, multiplier, destination);
+        public static void AcosPi<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, AcosPiOperator<T>>(x, destination);
 
-        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for 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="multiplier">The third tensor, represented as a scalar.</param>
+        /// <summary>Computes the element-wise angle in radians whose sine is the specifed number.</summary>
+        /// <param name="x">The 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] = (<paramref name="x" />[i] + <paramref name="y" />[i]) * <paramref name="multiplier" /></c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Asin(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
-        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// 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 AddMultiply<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T multiplier, Span<T> destination)
-            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
-            InvokeSpanSpanScalarIntoSpan<T, AddMultiplyOperator<T>>(x, y, multiplier, destination);
+        public static void Asin<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, AsinOperator<T>>(x, destination);
 
-        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for 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="multiplier">The third tensor, represented as a span.</param>
+        /// <summary>Computes the element-wise hyperbolic arc-sine of the specifed number.</summary>
+        /// <param name="x">The 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="multiplier" />.</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="multiplier"/> 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] = (<paramref name="x" />[i] + <paramref name="y" />) * <paramref name="multiplier" />[i]</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Asinh(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
-        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// 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 AddMultiply<T>(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> multiplier, Span<T> destination)
-            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
-            InvokeSpanScalarSpanIntoSpan<T, AddMultiplyOperator<T>>(x, y, multiplier, destination);
+        public static void Asinh<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IHyperbolicFunctions<T> =>
+            InvokeSpanIntoSpan<T, AsinhOperator<T>>(x, destination);
 
-        /// <summary>Computes the element-wise hyperbolic cosine of each radian angle in the specified tensor.</summary>
+        /// <summary>Computes the element-wise angle in radians whose sine is the specifed number and divides the result by Pi.</summary>
         /// <param name="x">The tensor, represented as a span.</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] = <see cref="MathF" />.Cosh(<paramref name="x" />[i])</c>.
-        /// </para>
-        /// <para>
-        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/> or <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
-        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is also NaN.
-        /// </para>
-        /// <para>
-        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <see cref="MathF.PI"/>/180 to convert degrees to radians.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.AsinPi(<paramref name="x" />[i])</c>.
         /// </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 Cosh<T>(ReadOnlySpan<T> x, Span<T> destination)
-            where T : IHyperbolicFunctions<T> =>
-            InvokeSpanIntoSpan<T, CoshOperator<T>>(x, destination);
+        public static void AsinPi<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, AsinPiOperator<T>>(x, destination);
 
-        /// <summary>Computes the cosine similarity between the two specified non-empty, equal-length tensors of numbers.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <returns>The cosine similarity of the two tensors.</returns>
-        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
-        /// <exception cref="ArgumentException"><paramref name="x" /> and <paramref name="y" /> must not be empty.</exception>
+        /// <summary>Computes the element-wise angle in radians whose tangent is the specifed number.</summary>
+        /// <param name="x">The tensor, represented as a span.</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>TensorPrimitives.Dot(x, y) / (MathF.Sqrt(TensorPrimitives.SumOfSquares(x)) * MathF.Sqrt(TensorPrimitives.SumOfSquares(y)).</c>
-        /// </para>
-        /// <para>
-        /// If any element in either input tensor is equal to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>, <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, or <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
-        /// NaN is returned.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Atan(<paramref name="x" />[i])</c>.
         /// </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 CosineSimilarity<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
-            where T : IRootFunctions<T> =>
-            CosineSimilarityCore(x, y);
+        public static void Atan<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, AtanOperator<T>>(x, destination);
 
-        /// <summary>Computes the distance between two points, specified as non-empty, equal-length tensors of numbers, in Euclidean space.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <returns>The Euclidean distance.</returns>
-        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
-        /// <exception cref="ArgumentException"><paramref name="x" /> and <paramref name="y" /> must not be empty.</exception>
+        /// <summary>Computes the element-wise hyperbolic arc-tangent of the specifed number.</summary>
+        /// <param name="x">The tensor, represented as a span.</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 the equivalent of:
-        /// <c>
-        ///     Span&lt;T&gt; difference = ...;
-        ///     TensorPrimitives.Subtract(x, y, difference);
-        ///     T result = MathF.Sqrt(TensorPrimitives.SumOfSquares(difference));
-        /// </c>
-        /// but without requiring additional temporary storage for the intermediate differences.
-        /// </para>
-        /// <para>
-        /// If any element in either input tensor is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, NaN is returned.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Atanh(<paramref name="x" />[i])</c>.
         /// </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 Distance<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
-            where T : IRootFunctions<T>
-        {
-            if (x.IsEmpty)
-            {
-                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
-            }
-
-            return T.Sqrt(Aggregate<T, SubtractSquaredOperator<T>, AddOperator<T>>(x, y));
-        }
+        public static void Atanh<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IHyperbolicFunctions<T> =>
+            InvokeSpanIntoSpan<T, AtanhOperator<T>>(x, destination);
 
-        /// <summary>Computes the element-wise division of numbers 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>
+        /// <summary>Computes the element-wise angle in radians whose tangent is the specifed number and divides the result by Pi.</summary>
+        /// <param name="x">The 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>
-        /// <exception cref="DivideByZeroException"><typeparamref name="T"/> is an integer type and an element in <paramref name="y"/> is equal to zero.</exception>
         /// <remarks>
         /// <para>
-        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] / <paramref name="y" />[i]</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.AtanPi(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
-        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// 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 Divide<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
-            where T : IDivisionOperators<T, T, T> =>
-            InvokeSpanSpanIntoSpan<T, DivideOperator<T>>(x, y, destination);
+        public static void AtanPi<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, AtanPiOperator<T>>(x, destination);
 
-        /// <summary>Computes the element-wise division of numbers 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>
+        /// <summary>Computes the element-wise arc-tangent for the quotient of two values in the specified tensors.</summary>
+        /// <param name="y">The first tensor, represented as a span.</param>
+        /// <param name="x">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="y" /> must be same as length of <paramref name="x" />.</exception>
         /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</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="DivideByZeroException"><typeparamref name="T"/> is an integer type and <paramref name="y"/> is equal to zero.</exception>
         /// <remarks>
         /// <para>
-        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] / <paramref name="y" /></c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Atan2(<paramref name="y" />[i], <paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
-        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// 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 Divide<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
-            where T : IDivisionOperators<T, T, T> =>
-            InvokeSpanScalarIntoSpan<T, DivideOperator<T>>(x, y, destination);
+        public static void Atan2<T>(ReadOnlySpan<T> y, ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanSpanIntoSpan<T, Atan2Operator<T>>(y, x, destination);
 
-        /// <summary>Computes the dot product of two tensors containing numbers.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <returns>The dot product.</returns>
-        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <summary>Computes the element-wise arc-tangent for the quotient of two values in the specified tensors.</summary>
+        /// <param name="y">The first tensor, represented as a span.</param>
+        /// <param name="x">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="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
         /// <remarks>
         /// <para>
-        /// This method effectively computes the equivalent of:
-        /// <c>
-        ///     Span&lt;T&gt; products = ...;
-        ///     TensorPrimitives.Multiply(x, y, products);
-        ///     T result = TensorPrimitives.Sum(products);
-        /// </c>
-        /// but without requiring additional temporary storage for the intermediate products. It corresponds to the <c>dot</c> method defined by <c>BLAS1</c>.
-        /// </para>
-        /// <para>
-        /// If any of the input elements is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting value is also NaN.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Atan2(<paramref name="y" />[i], <paramref name="x" />)</c>.
         /// </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 Dot<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T> =>
-            Aggregate<T, MultiplyOperator<T>, AddOperator<T>>(x, y);
+        public static void Atan2<T>(ReadOnlySpan<T> y, T x, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanScalarIntoSpan<T, Atan2Operator<T>>(y, x, destination);
 
-        /// <summary>Computes the element-wise result of raising <c>e</c> to the number powers in the specified tensor.</summary>
-        /// <param name="x">The tensor, represented as a span.</param>
+        /// <summary>Computes the element-wise arc-tangent for the quotient of two values in the specified tensors.</summary>
+        /// <param name="y">The first tensor, represented as a scalar.</param>
+        /// <param name="x">The second tensor, represented as a span.</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] = <see cref="MathF" />.Exp(<paramref name="x" />[i])</c>.
-        /// </para>
-        /// <para>
-        /// If a value equals <see cref="IFloatingPointIeee754{TSelf}.NaN"/> or <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, the result stored into the corresponding destination location is set to NaN.
-        /// If a value equals <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>, the result stored into the corresponding destination location is set to 0.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Atan2(<paramref name="y" />, <paramref name="x" />[i])</c>.
         /// </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 Exp<T>(ReadOnlySpan<T> x, Span<T> destination)
-            where T : IExponentialFunctions<T> =>
-            InvokeSpanIntoSpan<T, ExpOperator<T>>(x, destination);
-
-        // TODO: Make IndexOfXx methods generic
-        //
-        ///// <summary>Searches for the index of the largest 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.</returns>
-        ///// <remarks>
-        ///// <para>
-        ///// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
-        ///// is present, the index of the first is returned. 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 IndexOfMax<T>(ReadOnlySpan<T> x)
-        //    where T : INumber<T> =>
-        //    IndexOfMinMaxCore<T, IndexOfMaxOperator<T>>(x);
-        //
-        ///// <summary>Searches for the index of the 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.</returns>
-        ///// <remarks>
-        ///// <para>
-        ///// The determination of the maximum magnitude matches the IEEE 754:2019 `maximumMagnitude` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
-        ///// is present, the index of the first is returned. 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 IndexOfMaxMagnitude<T>(ReadOnlySpan<T> x)
-        //    where T : INumberBase<T> =>
-        //    IndexOfMinMaxCore<T, IndexOfMaxMagnitudeOperator<T>>(x);
-        //
-        ///// <summary>Searches for the index of the smallest 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.</returns>
-        ///// <remarks>
-        ///// <para>
-        ///// The determination of the minimum element matches the IEEE 754:2019 `minimum` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
-        ///// is present, the index of the first is returned. 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 IndexOfMin<T>(ReadOnlySpan<T> x)
-        //    where T : INumber<T> =>
-        //    IndexOfMinMaxCore<T, IndexOfMinOperator<T>>(x);
-        //
-        ///// <summary>Searches for the index of the 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.</returns>
-        ///// <remarks>
-        ///// <para>
-        ///// The determination of the minimum magnitude matches the IEEE 754:2019 `minimumMagnitude` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
-        ///// is present, the index of the first is returned. 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 IndexOfMinMagnitude<T>(ReadOnlySpan<T> x)
-        //    where T : INumberBase<T> =>
-        //    IndexOfMinMaxCore<T, IndexOfMinMagnitudeOperator<T>>(x);
+        public static void Atan2<T>(T y, ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeScalarSpanIntoSpan<T, Atan2Operator<T>>(y, x, destination);
 
-        /// <summary>Computes the element-wise natural (base <c>e</c>) logarithm of numbers in the specified tensor.</summary>
-        /// <param name="x">The tensor, represented as a span.</param>
+        /// <summary>Computes the element-wise arc-tangent for the quotient of two values in the specified tensors and divides the result by Pi.</summary>
+        /// <param name="y">The first tensor, represented as a span.</param>
+        /// <param name="x">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="y" /> must be same as length of <paramref name="x" />.</exception>
         /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</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] = <see cref="MathF" />.Log(<paramref name="x" />[i])</c>.
-        /// </para>
-        /// <para>
-        /// If a value equals 0, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>.
-        /// If a value is negative or equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is set to NaN.
-        /// If a value is positive infinity, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
-        /// Otherwise, if a value is positive, its natural logarithm is stored into the corresponding destination location.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Atan2(<paramref name="y" />[i], <paramref name="x" />[i])</c>.
         /// </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 Log<T>(ReadOnlySpan<T> x, Span<T> destination)
-            where T : ILogarithmicFunctions<T> =>
-            InvokeSpanIntoSpan<T, LogOperator<T>>(x, destination);
+        public static void Atan2Pi<T>(ReadOnlySpan<T> y, ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanSpanIntoSpan<T, Atan2PiOperator<T>>(y, x, destination);
 
-        /// <summary>Computes the element-wise base 2 logarithm of numbers in the specified tensor.</summary>
-        /// <param name="x">The tensor, represented as a span.</param>
+        /// <summary>Computes the element-wise arc-tangent for the quotient of two values in the specified tensors and divides the result by Pi.</summary>
+        /// <param name="y">The first tensor, represented as a span.</param>
+        /// <param name="x">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>
+        /// <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] = <see cref="MathF" />.Log2(<paramref name="x" />[i])</c>.
-        /// </para>
-        /// <para>
-        /// If a value equals 0, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>.
-        /// If a value is negative or equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is set to NaN.
-        /// If a value is positive infinity, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
-        /// Otherwise, if a value is positive, its natural logarithm is stored into the corresponding destination location.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Atan2(<paramref name="y" />[i], <paramref name="x" />)</c>.
         /// </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 Log2<T>(ReadOnlySpan<T> x, Span<T> destination)
-            where T : ILogarithmicFunctions<T> =>
-            InvokeSpanIntoSpan<T, Log2Operator<T>>(x, destination);
+        public static void Atan2Pi<T>(ReadOnlySpan<T> y, T x, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanScalarIntoSpan<T, Atan2PiOperator<T>>(y, x, destination);
 
-        /// <summary>Searches for the largest number in the specified tensor.</summary>
-        /// <param name="x">The tensor, represented as a span.</param>
-        /// <returns>The maximum element in <paramref name="x"/>.</returns>
-        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+        /// <summary>Computes the element-wise arc-tangent for the quotient of two values in the specified tensors and divides the result by Pi.</summary>
+        /// <param name="y">The first tensor, represented as a scalar.</param>
+        /// <param name="x">The second tensor, represented as a span.</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>
-        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
-        /// is present, the first is returned. Positive 0 is considered greater than negative 0.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Atan2(<paramref name="y" />, <paramref name="x" />[i])</c>.
         /// </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 Max<T>(ReadOnlySpan<T> x)
-            where T : INumber<T> =>
-            MinMaxCore<T, MaxOperator<T>>(x);
+        public static void Atan2Pi<T>(T y, ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeScalarSpanIntoSpan<T, Atan2PiOperator<T>>(y, x, destination);
 
-        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
+        /// <summary>Computes the element-wise addition of numbers 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>
@@ -452,80 +321,60 @@ public static T Max<T>(ReadOnlySpan<T> x)
         /// <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] = MathF.Max(<paramref name="x" />[i], <paramref name="y" />[i])</c>.
-        /// </para>
-        /// <para>
-        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
-        /// that value is stored as the result. Positive 0 is considered greater than negative 0.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] + <paramref name="y" />[i]</c>.
         /// </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.
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
         /// </para>
         /// </remarks>
-        public static void Max<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
-            where T : INumber<T> =>
-            InvokeSpanSpanIntoSpan<T, MaxPropagateNaNOperator<T>>(x, y, destination);
+        public static void Add<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T> =>
+            InvokeSpanSpanIntoSpan<T, AddOperator<T>>(x, y, destination);
 
-        /// <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>
+        /// <summary>Computes the element-wise addition of numbers 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>
-        /// The determination of the maximum magnitude matches the IEEE 754:2019 `maximumMagnitude` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
-        /// is present, the first is returned. 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.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] + <paramref name="y" /></c>.
         /// </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.
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
         /// </para>
         /// </remarks>
-        public static T MaxMagnitude<T>(ReadOnlySpan<T> x)
-            where T : INumberBase<T> =>
-            MinMaxCore<T, MaxMagnitudeOperator<T>>(x);
+        public static void Add<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T> =>
+            InvokeSpanScalarIntoSpan<T, AddOperator<T>>(x, y, destination);
 
-        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for 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="multiplier">The third 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">Length of <paramref name="x" /> must be same as length of <paramref name="y" /> and the length of <paramref name="multiplier" />.</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>This method effectively computes <c><paramref name="destination" />[i] = MathF.MaxMagnitude(<paramref name="x" />[i], <paramref name="y" />[i])</c>.</remarks>
-        /// <remarks>
-        /// <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 MaxMagnitude<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
-            where T : INumberBase<T> =>
-            InvokeSpanSpanIntoSpan<T, MaxMagnitudePropagateNaNOperator<T>>(x, y, destination);
-
-        /// <summary>Searches for the smallest number in the specified tensor.</summary>
-        /// <param name="x">The tensor, represented as a span.</param>
-        /// <returns>The minimum element in <paramref name="x"/>.</returns>
-        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+        /// <exception cref="ArgumentException"><paramref name="multiplier"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
         /// <remarks>
         /// <para>
-        /// The determination of the minimum element matches the IEEE 754:2019 `minimum` function. If any value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
-        /// is present, the first is returned. Negative 0 is considered smaller than positive 0.
+        /// This method effectively computes <c><paramref name="destination" />[i] = (<paramref name="x" />[i] + <paramref name="y" />[i]) * <paramref name="multiplier" />[i]</c>.
         /// </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.
+        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
         /// </para>
         /// </remarks>
-        public static T Min<T>(ReadOnlySpan<T> x)
-            where T : INumber<T> =>
-            MinMaxCore<T, MinOperator<T>>(x);
+        public static void AddMultiply<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> multiplier, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanSpanSpanIntoSpan<T, AddMultiplyOperator<T>>(x, y, multiplier, destination);
 
-        /// <summary>Computes the element-wise minimum of the numbers in the specified tensors.</summary>
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for 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="multiplier">The third tensor, represented as a scalar.</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>
@@ -533,41 +382,38 @@ public static T Min<T>(ReadOnlySpan<T> x)
         /// <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] = MathF.Max(<paramref name="x" />[i], <paramref name="y" />[i])</c>.
-        /// </para>
-        /// <para>
-        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
-        /// that value is stored as the result. Positive 0 is considered greater than negative 0.
+        /// This method effectively computes <c><paramref name="destination" />[i] = (<paramref name="x" />[i] + <paramref name="y" />[i]) * <paramref name="multiplier" /></c>.
         /// </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.
+        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
         /// </para>
         /// </remarks>
-        public static void Min<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
-            where T : INumber<T> =>
-            InvokeSpanSpanIntoSpan<T, MinPropagateNaNOperator<T>>(x, y, destination);
+        public static void AddMultiply<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T multiplier, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanSpanScalarIntoSpan<T, AddMultiplyOperator<T>>(x, y, multiplier, destination);
 
-        /// <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>
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for 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="multiplier">The third 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="multiplier" />.</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="multiplier"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
         /// <remarks>
         /// <para>
-        /// The determination of the minimum magnitude matches the IEEE 754:2019 `minimumMagnitude` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
-        /// is present, the first is returned. 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.
+        /// This method effectively computes <c><paramref name="destination" />[i] = (<paramref name="x" />[i] + <paramref name="y" />) * <paramref name="multiplier" />[i]</c>.
         /// </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.
+        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
         /// </para>
         /// </remarks>
-        public static T MinMagnitude<T>(ReadOnlySpan<T> x)
-            where T : INumberBase<T> =>
-            MinMaxCore<T, MinMagnitudeOperator<T>>(x);
+        public static void AddMultiply<T>(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> multiplier, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanScalarSpanIntoSpan<T, AddMultiplyOperator<T>>(x, y, multiplier, destination);
 
-        /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
+        /// <summary>Computes the element-wise bitwise AND of numbers 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>
@@ -575,23 +421,31 @@ public static T MinMagnitude<T>(ReadOnlySpan<T> x)
         /// <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>This method effectively computes <c><paramref name="destination" />[i] = MathF.MinMagnitude(<paramref name="x" />[i], <paramref name="y" />[i])</c>.</remarks>
         /// <remarks>
         /// <para>
-        /// The determination of the maximum magnitude matches the IEEE 754:2019 `minimumMagnitude` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
-        /// that value is stored as the result. 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.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] &amp; <paramref name="y" />[i]</c>.
         /// </para>
+        /// </remarks>
+        public static void BitwiseAnd<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IBitwiseOperators<T, T, T> =>
+            InvokeSpanSpanIntoSpan<T, BitwiseAndOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise bitwise AND of numbers 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 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.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] &amp; <paramref name="y" /></c>.
         /// </para>
         /// </remarks>
-        public static void MinMagnitude<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
-            where T : INumberBase<T> =>
-            InvokeSpanSpanIntoSpan<T, MinMagnitudePropagateNaNOperator<T>>(x, y, destination);
+        public static void BitwiseAnd<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : IBitwiseOperators<T, T, T> =>
+            InvokeSpanScalarIntoSpan<T, BitwiseAndOperator<T>>(x, y, destination);
 
-        /// <summary>Computes the element-wise product of numbers in the specified tensors.</summary>
+        /// <summary>Computes the element-wise bitwise OR of numbers 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>
@@ -601,17 +455,14 @@ public static void MinMagnitude<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T>
         /// <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] = <paramref name="x" />[i] * <paramref name="y" />[i]</c>.
-        /// </para>
-        /// <para>
-        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] | <paramref name="y" />[i]</c>.
         /// </para>
         /// </remarks>
-        public static void Multiply<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
-            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T> =>
-            InvokeSpanSpanIntoSpan<T, MultiplyOperator<T>>(x, y, destination);
+        public static void BitwiseOr<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IBitwiseOperators<T, T, T> =>
+            InvokeSpanSpanIntoSpan<T, BitwiseOrOperator<T>>(x, y, destination);
 
-        /// <summary>Computes the element-wise product of numbers in the specified tensors.</summary>
+        /// <summary>Computes the element-wise bitwise OR of numbers 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>
@@ -619,206 +470,1808 @@ public static void Multiply<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> des
         /// <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] = <paramref name="x" />[i] * <paramref name="y" /></c>.
-        /// It corresponds to the <c>scal</c> method defined by <c>BLAS1</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] | <paramref name="y" /></c>.
         /// </para>
+        /// </remarks>
+        public static void BitwiseOr<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : IBitwiseOperators<T, T, T> =>
+            InvokeSpanScalarIntoSpan<T, BitwiseOrOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise ceiling of numbers in the specified tensor.</summary>
+        /// <param name="x">The first tensor, represented as a span.</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>
-        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// This method effectively computes <c><paramref name="destination" />[i] = T.Ceiling(<paramref name="x" />[i])</c>.
         /// </para>
         /// </remarks>
-        public static void Multiply<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
-            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T> =>
-            InvokeSpanScalarIntoSpan<T, MultiplyOperator<T>>(x, y, destination);
+        public static void Ceiling<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPoint<T> =>
+            InvokeSpanIntoSpan<T, CeilingOperator<T>>(x, destination);
 
-        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</summary>
+        /// <summary>Computes the element-wise result of copying the sign from one number to another number 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="addend">The third tensor, represented as a span.</param>
+        /// <param name="sign">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" /> and length of <paramref name="addend" />.</exception>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="sign" />.</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>
-        /// <exception cref="ArgumentException"><paramref name="addend"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="sign"/> 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] = (<paramref name="x" />[i] * <paramref name="y" />[i]) + <paramref name="addend" />[i]</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = T.CopySign(<paramref name="x" />[i], <paramref name="sign" />[i])</c>.
         /// </para>
+        /// </remarks>
+        public static void CopySign<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> sign, Span<T> destination)
+            where T : INumber<T> =>
+            InvokeSpanSpanIntoSpan<T, CopySignOperator<T>>(x, sign, destination);
+
+        /// <summary>Computes the element-wise result of copying the sign from one number to another number in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="sign">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>
-        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// This method effectively computes <c><paramref name="destination" />[i] = T.CopySign(<paramref name="x" />[i], <paramref name="sign" />[i])</c>.
         /// </para>
         /// </remarks>
-        public static void MultiplyAdd<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> addend, Span<T> destination)
-            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
-            InvokeSpanSpanSpanIntoSpan<T, MultiplyAddOperator<T>>(x, y, addend, destination);
+        public static void CopySign<T>(ReadOnlySpan<T> x, T sign, Span<T> destination)
+            where T : INumber<T> =>
+            InvokeSpanScalarIntoSpan<T, CopySignOperator<T>>(x, sign, destination);
 
-        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</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="addend">The third tensor, represented as a scalar.</param>
+        /// <summary>Computes the element-wise cosine of the value in the specified tensor.</summary>
+        /// <param name="x">The 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] = (<paramref name="x" />[i] * <paramref name="y" />[i]) + <paramref name="addend" /></c>.
-        /// It corresponds to the <c>axpy</c> method defined by <c>BLAS1</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Cos(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
-        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi/180 to convert degrees to radians.
+        /// </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 MultiplyAdd<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T addend, Span<T> destination)
-            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
-            InvokeSpanSpanScalarIntoSpan<T, MultiplyAddOperator<T>>(x, y, addend, destination);
+        public static void Cos<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, CosOperator<T>>(x, destination);
 
-        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</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="addend">The third tensor, represented as a span.</param>
+        /// <summary>Computes the element-wise cosine of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="x">The 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="addend" />.</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="addend"/> 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] = (<paramref name="x" />[i] * <paramref name="y" />) + <paramref name="addend" />[i]</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.CosPi(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
-        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi/180 to convert degrees to radians.
+        /// </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 MultiplyAdd<T>(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> addend, Span<T> destination)
-            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
-            InvokeSpanScalarSpanIntoSpan<T, MultiplyAddOperator<T>>(x, y, addend, destination);
+        public static void CosPi<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, CosPiOperator<T>>(x, destination);
 
-        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
+        /// <summary>Computes the element-wise hyperbolic cosine of each radian angle in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</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] = -<paramref name="x" />[i]</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Cosh(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
-        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/> or <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
+        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is also NaN.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi/180 to convert degrees to radians.
+        /// </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 Negate<T>(ReadOnlySpan<T> x, Span<T> destination)
-            where T : IUnaryNegationOperators<T, T> =>
-            InvokeSpanIntoSpan<T, NegateOperator<T>>(x, destination);
+        public static void Cosh<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IHyperbolicFunctions<T> =>
+            InvokeSpanIntoSpan<T, CoshOperator<T>>(x, destination);
 
-        /// <summary>Computes the Euclidean norm of the specified tensor of numbers.</summary>
+        /// <summary>Computes the cosine similarity between the two specified non-empty, equal-length tensors of numbers.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
-        /// <returns>The norm.</returns>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <returns>The cosine similarity of the two tensors.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x" /> and <paramref name="y" /> must not be empty.</exception>
         /// <remarks>
         /// <para>
-        /// This method effectively computes <c>MathF.Sqrt(TensorPrimitives.SumOfSquares(x))</c>.
-        /// This is often referred to as the Euclidean norm or L2 norm.
-        /// It corresponds to the <c>nrm2</c> method defined by <c>BLAS1</c>.
+        /// This method effectively computes <c>TensorPrimitives.Dot(x, y) / (<typeparamref name="T"/>.Sqrt(TensorPrimitives.SumOfSquares(x)) * <typeparamref name="T"/>.Sqrt(TensorPrimitives.SumOfSquares(y)).</c>
         /// </para>
         /// <para>
-        /// If any of the input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result value is also NaN.
+        /// If any element in either input tensor is equal to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>, <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, or <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// NaN is returned.
         /// </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 Norm<T>(ReadOnlySpan<T> x)
+        public static T CosineSimilarity<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
             where T : IRootFunctions<T> =>
-            T.Sqrt(SumOfSquares(x));
+            CosineSimilarityCore(x, y);
+
+        /// <summary>Computes the element-wise cube root of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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] = T.Cbrt(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void Cbrt<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IRootFunctions<T> =>
+            InvokeSpanIntoSpan<T, CbrtOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise conversion of each number of degrees in the specified tensor to radiansx.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.DegreesToRadians(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void DegreesToRadians<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, DegreesToRadiansOperator<T>>(x, destination);
+
+        /// <summary>Computes the distance between two points, specified as non-empty, equal-length tensors of numbers, in Euclidean space.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <returns>The Euclidean distance.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x" /> and <paramref name="y" /> must not be empty.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes the equivalent of:
+        /// <c>
+        ///     Span&lt;T&gt; difference = ...;
+        ///     TensorPrimitives.Subtract(x, y, difference);
+        ///     T result = <typeparamref name="T"/>.Sqrt(TensorPrimitives.SumOfSquares(difference));
+        /// </c>
+        /// but without requiring additional temporary storage for the intermediate differences.
+        /// </para>
+        /// <para>
+        /// If any element in either input tensor is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, NaN is returned.
+        /// </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 Distance<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
+            where T : IRootFunctions<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            return T.Sqrt(Aggregate<T, SubtractSquaredOperator<T>, AddOperator<T>>(x, y));
+        }
+
+        /// <summary>Computes the element-wise division of numbers 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>
+        /// <exception cref="DivideByZeroException"><typeparamref name="T"/> is an integer type and an element in <paramref name="y"/> is equal to zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] / <paramref name="y" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Divide<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IDivisionOperators<T, T, T> =>
+            InvokeSpanSpanIntoSpan<T, DivideOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise division of numbers 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>
+        /// <exception cref="DivideByZeroException"><typeparamref name="T"/> is an integer type and <paramref name="y"/> is equal to zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] / <paramref name="y" /></c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Divide<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : IDivisionOperators<T, T, T> =>
+            InvokeSpanScalarIntoSpan<T, DivideOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise division of numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a scalar.</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">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="DivideByZeroException"><typeparamref name="T"/> is an integer type and an element in <paramref name="y"/> is equal to zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" /> / <paramref name="y" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Divide<T>(T x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IDivisionOperators<T, T, T> =>
+            InvokeScalarSpanIntoSpan<T, DivideOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the dot product of two tensors containing numbers.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <returns>The dot product.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes the equivalent of:
+        /// <c>
+        ///     Span&lt;T&gt; products = ...;
+        ///     TensorPrimitives.Multiply(x, y, products);
+        ///     T result = TensorPrimitives.Sum(products);
+        /// </c>
+        /// but without requiring additional temporary storage for the intermediate products. It corresponds to the <c>dot</c> method defined by <c>BLAS1</c>.
+        /// </para>
+        /// <para>
+        /// If any of the input elements is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting value is also NaN.
+        /// </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 Dot<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T> =>
+            Aggregate<T, MultiplyOperator<T>, AddOperator<T>>(x, y);
+
+        /// <summary>Computes the element-wise result of raising <c>e</c> to the number powers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Exp(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value equals <see cref="IFloatingPointIeee754{TSelf}.NaN"/> or <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, the result stored into the corresponding destination location is set to NaN.
+        /// If a value equals <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>, the result stored into the corresponding destination location is set to 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 void Exp<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IExponentialFunctions<T> =>
+            InvokeSpanIntoSpan<T, ExpOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise result of raising <c>e</c> to the number powers in the specified tensor, minus 1.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.ExpM1(<paramref name="x" />[i])</c>.
+        /// </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 ExpM1<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IExponentialFunctions<T> =>
+            InvokeSpanIntoSpan<T, ExpM1Operator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Exp2(<paramref name="x" />[i])</c>.
+        /// </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 Exp2<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IExponentialFunctions<T> =>
+            InvokeSpanIntoSpan<T, Exp2Operator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Exp2M1(<paramref name="x" />[i])</c>.
+        /// </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 Exp2M1<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IExponentialFunctions<T> =>
+            InvokeSpanIntoSpan<T, Exp2M1Operator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise result of raising 10 to the number powers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Exp10(<paramref name="x" />[i])</c>.
+        /// </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 Exp10<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IExponentialFunctions<T> =>
+            InvokeSpanIntoSpan<T, Exp10Operator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise result of raising 10 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Exp10M1(<paramref name="x" />[i])</c>.
+        /// </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 Exp10M1<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IExponentialFunctions<T> =>
+            InvokeSpanIntoSpan<T, Exp10M1Operator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise floor of numbers in the specified tensor.</summary>
+        /// <param name="x">The first tensor, represented as a span.</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] = T.Floor(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void Floor<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPoint<T> =>
+            InvokeSpanIntoSpan<T, FloorOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise hypotensue given values from two tensors representing the lengths of the shorter sides in a right-angled triangle.</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] = T.Hypot(<paramref name="x" />[i], <paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void Hypot<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IRootFunctions<T> =>
+            InvokeSpanSpanIntoSpan<T, HypotOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise remainder of the numbers 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] = T.Ieee754Remainder(<paramref name="x" />[i], <paramref name="y" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void Ieee754Remainder<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanSpanIntoSpan<T, Ieee754RemainderOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise remainder of the numbers 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">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>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = T.Ieee754Remainder(<paramref name="x" />[i], <paramref name="y" />)</c>.
+        /// </para>
+        /// </remarks>
+        public static void Ieee754Remainder<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanScalarIntoSpan<T, Ieee754RemainderOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a scalar.</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">Destination is too short.</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] = T.Ieee754Remainder(<paramref name="x" />, <paramref name="y" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void Ieee754Remainder<T>(T x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeScalarSpanIntoSpan<T, Ieee754RemainderOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise integer logarithm of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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] = T.ILogB(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void ILogB<T>(ReadOnlySpan<T> x, Span<int> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            // TODO: Vectorize
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = T.ILogB(x[i]);
+            }
+        }
+
+        /// <summary>Searches for the index of the largest 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.</returns>
+        /// <remarks>
+        /// <para>
+        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If any value equal to NaN
+        /// is present, the index of the first is returned. 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 IndexOfMax<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            IndexOfMinMaxCore<T, IndexOfMaxOperator<T>>(x);
+
+        /// <summary>Searches for the index of the 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.</returns>
+        /// <remarks>
+        /// <para>
+        /// The determination of the maximum magnitude matches the IEEE 754:2019 `maximumMagnitude` function. If any value equal to NaN
+        /// is present, the index of the first is returned. 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 IndexOfMaxMagnitude<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            IndexOfMinMaxCore<T, IndexOfMaxMagnitudeOperator<T>>(x);
+
+        /// <summary>Searches for the index of the smallest 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.</returns>
+        /// <remarks>
+        /// <para>
+        /// The determination of the minimum element matches the IEEE 754:2019 `minimum` function. If any value equal to NaN
+        /// is present, the index of the first is returned. 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 IndexOfMin<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            IndexOfMinMaxCore<T, IndexOfMinOperator<T>>(x);
+
+        /// <summary>Searches for the index of the 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.</returns>
+        /// <remarks>
+        /// <para>
+        /// The determination of the minimum magnitude matches the IEEE 754:2019 `minimumMagnitude` function. If any value equal to NaN
+        /// is present, the index of the first is returned. 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 IndexOfMinMagnitude<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            IndexOfMinMaxCore<T, IndexOfMinMagnitudeOperator<T>>(x);
+
+        /// <summary>Computes the element-wise leading zero count of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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] = T.LeadingZeroCount(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void LeadingZeroCount<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IBinaryInteger<T> =>
+            InvokeSpanIntoSpan<T, LeadingZeroCountOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise linear interpolation between two values based on the given weight in the specified tensors of numbers.</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="amount">The third 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" /> and length of <paramref name="amount" />.</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>
+        /// <exception cref="ArgumentException"><paramref name="amount"/> 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] = T.Lerp(<paramref name="x" />[i], <paramref name="y" />[i], <paramref name="amount" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Lerp<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> amount, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanSpanSpanIntoSpan<T, LerpOperator<T>>(x, y, amount, destination);
+
+        /// <summary>Computes the element-wise linear interpolation between two values based on the given weight in the specified tensors of numbers.</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="amount">The third tensor, represented as a scalar.</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] = T.Lerp(<paramref name="x" />[i], <paramref name="y" />[i], <paramref name="amount" />)</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Lerp<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T amount, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanSpanScalarIntoSpan<T, LerpOperator<T>>(x, y, amount, destination);
+
+        /// <summary>Computes the element-wise linear interpolation between two values based on the given weight in the specified tensors of numbers.</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="amount">The third 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="amount" />.</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="amount"/> 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] = T.Lerp(<paramref name="x" />[i], <paramref name="y" />, <paramref name="amount" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Lerp<T>(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> amount, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanScalarSpanIntoSpan<T, LerpOperator<T>>(x, y, amount, destination);
+
+        /// <summary>Computes the element-wise natural (base <c>e</c>) logarithm of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Log(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value equals 0, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>.
+        /// If a value is negative or equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is set to NaN.
+        /// If a value is positive infinity, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
+        /// Otherwise, if a value is positive, its natural logarithm is stored into the corresponding destination location.
+        /// </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 Log<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ILogarithmicFunctions<T> =>
+            InvokeSpanIntoSpan<T, LogOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise base 2 logarithm of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Log2(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value equals 0, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>.
+        /// If a value is negative or equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is set to NaN.
+        /// If a value is positive infinity, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
+        /// Otherwise, if a value is positive, its base 2 logarithm is stored into the corresponding destination location.
+        /// </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 Log2<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ILogarithmicFunctions<T> =>
+            InvokeSpanIntoSpan<T, Log2Operator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise base 10 logarithm of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Log10(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value equals 0, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>.
+        /// If a value is negative or equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is set to NaN.
+        /// If a value is positive infinity, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
+        /// Otherwise, if a value is positive, its base 10 logarithm is stored into the corresponding destination location.
+        /// </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 Log10<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ILogarithmicFunctions<T> =>
+            InvokeSpanIntoSpan<T, Log10Operator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise natural (base <c>e</c>) logarithm of numbers in the specified tensor plus 1.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.LogP1(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value equals 0, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>.
+        /// If a value is negative or equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is set to NaN.
+        /// If a value is positive infinity, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
+        /// Otherwise, if a value is positive, its natural logarithm plus 1 is stored into the corresponding destination location.
+        /// </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 LogP1<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ILogarithmicFunctions<T> =>
+            InvokeSpanIntoSpan<T, LogP1Operator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise base 2 logarithm of numbers in the specified tensor plus 1.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Log2P1(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value equals 0, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>.
+        /// If a value is negative or equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is set to NaN.
+        /// If a value is positive infinity, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
+        /// Otherwise, if a value is positive, its base 2 logarithm plus 1 is stored into the corresponding destination location.
+        /// </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 Log2P1<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ILogarithmicFunctions<T> =>
+            InvokeSpanIntoSpan<T, Log2P1Operator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise base 10 logarithm of numbers in the specified tensor plus 1.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Log10P1(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value equals 0, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>.
+        /// If a value is negative or equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is set to NaN.
+        /// If a value is positive infinity, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
+        /// Otherwise, if a value is positive, its base 10 logarithm plus 1 is stored into the corresponding destination location.
+        /// </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 Log10P1<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ILogarithmicFunctions<T> =>
+            InvokeSpanIntoSpan<T, Log10P1Operator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise logarithm of the numbers in a specified tensor to the specified base in another specified tensor.</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"/>.Log(<paramref name="x" />[i], <paramref name="y" />[i])</c>.
+        /// </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 Log<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : ILogarithmicFunctions<T> =>
+            InvokeSpanSpanIntoSpan<T, LogBaseOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise logarithm of the numbers in a specified tensor to the specified base in another specified tensor.</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"/>.Log(<paramref name="x" />[i], <paramref name="y" />)</c>.
+        /// </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 Log<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : ILogarithmicFunctions<T> =>
+            InvokeSpanScalarIntoSpan<T, LogBaseOperator<T>>(x, y, destination);
+
+        /// <summary>Searches for the largest number in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The maximum element in <paramref name="x"/>.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        /// is present, the first is returned. 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 T Max<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            MinMaxCore<T, MaxOperator<T>>(x);
+
+        /// <summary>Computes the element-wise maximum of the numbers 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"/>.Max(<paramref name="x" />[i], <paramref name="y" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// that value is stored as the result. 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 void Max<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : INumber<T> =>
+            InvokeSpanSpanIntoSpan<T, MaxPropagateNaNOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise maximum of the numbers 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"/>.Max(<paramref name="x" />[i], <paramref name="y" />)</c>.
+        /// </para>
+        /// <para>
+        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// that value is stored as the result. 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 void Max<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : INumber<T> =>
+            InvokeSpanScalarIntoSpan<T, MaxPropagateNaNOperator<T>>(x, y, destination);
+
+        /// <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 `maximumMagnitude` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        /// is present, the first is returned. 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 MaxMagnitude<T>(ReadOnlySpan<T> x)
+            where T : INumberBase<T> =>
+            MinMaxCore<T, MaxMagnitudeOperator<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>This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.MaxMagnitude(<paramref name="x" />[i], <paramref name="y" />[i])</c>.</remarks>
+        /// <remarks>
+        /// <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 MaxMagnitude<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : INumberBase<T> =>
+            InvokeSpanSpanIntoSpan<T, MaxMagnitudePropagateNaNOperator<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>This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.MaxMagnitude(<paramref name="x" />[i], <paramref name="y" />)</c>.</remarks>
+        /// <remarks>
+        /// <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 MaxMagnitude<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : INumberBase<T> =>
+            InvokeSpanScalarIntoSpan<T, MaxMagnitudePropagateNaNOperator<T>>(x, y, destination);
+
+        /// <summary>Searches for the smallest number in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The minimum element in <paramref name="x"/>.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// The determination of the minimum element matches the IEEE 754:2019 `minimum` function. If any value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        /// is present, the first is returned. 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 T Min<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            MinMaxCore<T, MinOperator<T>>(x);
+
+        /// <summary>Computes the element-wise minimum of the numbers 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"/>.Max(<paramref name="x" />[i], <paramref name="y" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// that value is stored as the result. 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 void Min<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : INumber<T> =>
+            InvokeSpanSpanIntoSpan<T, MinPropagateNaNOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise minimum of the numbers 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"/>.Max(<paramref name="x" />[i], <paramref name="y" />)</c>.
+        /// </para>
+        /// <para>
+        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// that value is stored as the result. 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 void Min<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : INumber<T> =>
+            InvokeSpanScalarIntoSpan<T, MinPropagateNaNOperator<T>>(x, y, destination);
+
+        /// <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 `minimumMagnitude` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        /// is present, the first is returned. 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 MinMagnitude<T>(ReadOnlySpan<T> x)
+            where T : INumberBase<T> =>
+            MinMaxCore<T, MinMagnitudeOperator<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>This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.MinMagnitude(<paramref name="x" />[i], <paramref name="y" />[i])</c>.</remarks>
+        /// <remarks>
+        /// <para>
+        /// The determination of the maximum magnitude matches the IEEE 754:2019 `minimumMagnitude` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// that value is stored as the result. 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 MinMagnitude<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : INumberBase<T> =>
+            InvokeSpanSpanIntoSpan<T, MinMagnitudePropagateNaNOperator<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>This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.MinMagnitude(<paramref name="x" />[i], <paramref name="y" />)</c>.</remarks>
+        /// <remarks>
+        /// <para>
+        /// The determination of the maximum magnitude matches the IEEE 754:2019 `minimumMagnitude` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// that value is stored as the result. 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 MinMagnitude<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : INumberBase<T> =>
+            InvokeSpanScalarIntoSpan<T, MinMagnitudePropagateNaNOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise product of numbers 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] = <paramref name="x" />[i] * <paramref name="y" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Multiply<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T> =>
+            InvokeSpanSpanIntoSpan<T, MultiplyOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise product of numbers 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] = <paramref name="x" />[i] * <paramref name="y" /></c>.
+        /// It corresponds to the <c>scal</c> method defined by <c>BLAS1</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Multiply<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T> =>
+            InvokeSpanScalarIntoSpan<T, MultiplyOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</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="addend">The third 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" /> and length of <paramref name="addend" />.</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>
+        /// <exception cref="ArgumentException"><paramref name="addend"/> 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] = (<paramref name="x" />[i] * <paramref name="y" />[i]) + <paramref name="addend" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void MultiplyAdd<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> addend, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanSpanSpanIntoSpan<T, MultiplyAddOperator<T>>(x, y, addend, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</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="addend">The third tensor, represented as a scalar.</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] = (<paramref name="x" />[i] * <paramref name="y" />[i]) + <paramref name="addend" /></c>.
+        /// It corresponds to the <c>axpy</c> method defined by <c>BLAS1</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void MultiplyAdd<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T addend, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanSpanScalarIntoSpan<T, MultiplyAddOperator<T>>(x, y, addend, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</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="addend">The third 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="addend" />.</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="addend"/> 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] = (<paramref name="x" />[i] * <paramref name="y" />) + <paramref name="addend" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void MultiplyAdd<T>(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> addend, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanScalarSpanIntoSpan<T, MultiplyAddOperator<T>>(x, y, addend, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</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="addend">The third 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" /> and length of <paramref name="addend" />.</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>
+        /// <exception cref="ArgumentException"><paramref name="addend"/> 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] = (<paramref name="x" />[i] * <paramref name="y" />[i]) + <paramref name="addend" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void FusedMultiplyAdd<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> addend, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanSpanSpanIntoSpan<T, FusedMultiplyAddOperator<T>>(x, y, addend, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</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="addend">The third tensor, represented as a scalar.</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] = (<paramref name="x" />[i] * <paramref name="y" />[i]) + <paramref name="addend" /></c>.
+        /// It corresponds to the <c>axpy</c> method defined by <c>BLAS1</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void FusedMultiplyAdd<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T addend, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanSpanScalarIntoSpan<T, FusedMultiplyAddOperator<T>>(x, y, addend, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</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="addend">The third 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="addend" />.</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="addend"/> 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] = (<paramref name="x" />[i] * <paramref name="y" />) + <paramref name="addend" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void FusedMultiplyAdd<T>(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> addend, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanScalarSpanIntoSpan<T, FusedMultiplyAddOperator<T>>(x, y, addend, destination);
+
+        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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] = -<paramref name="x" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Negate<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IUnaryNegationOperators<T, T> =>
+            InvokeSpanIntoSpan<T, NegateOperator<T>>(x, destination);
+
+        /// <summary>Computes the Euclidean norm of the specified tensor of numbers.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <returns>The norm.</returns>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><typeparamref name="T"/>.Sqrt(TensorPrimitives.SumOfSquares(x))</c>.
+        /// This is often referred to as the Euclidean norm or L2 norm.
+        /// It corresponds to the <c>nrm2</c> method defined by <c>BLAS1</c>.
+        /// </para>
+        /// <para>
+        /// If any of the input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result value is also NaN.
+        /// </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 Norm<T>(ReadOnlySpan<T> x)
+            where T : IRootFunctions<T> =>
+            T.Sqrt(SumOfSquares(x));
+
+        /// <summary>Computes the element-wise one's complement of numbers in the specified tensor.</summary>
+        /// <param name="x">The first tensor, represented as a span.</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] = ~<paramref name="x" />[i]</c>.
+        /// </para>
+        /// </remarks>
+        public static void OnesComplement<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IBitwiseOperators<T, T, T> =>
+            InvokeSpanIntoSpan<T, OnesComplementOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise population count of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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] = T.PopCount(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void PopCount<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IBinaryInteger<T> =>
+            InvokeSpanIntoSpan<T, PopCountOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another 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] = T.Pow(<paramref name="x" />[i], <paramref name="y" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void Pow<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IPowerFunctions<T> =>
+            InvokeSpanSpanIntoSpan<T, PowOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another 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] = T.Pow(<paramref name="x" />[i], <paramref name="y" />)</c>.
+        /// </para>
+        /// </remarks>
+        public static void Pow<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : IPowerFunctions<T> =>
+            InvokeSpanScalarIntoSpan<T, PowOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a scalar.</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">Destination is too short.</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] = T.Pow(<paramref name="x" />, <paramref name="y" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void Pow<T>(T x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IPowerFunctions<T> =>
+            InvokeScalarSpanIntoSpan<T, PowOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the product of all elements in the specified non-empty tensor of numbers.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The result of multiplying all elements in <paramref name="x"/>.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// If any of the input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result value is also NaN.
+        /// </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 Product<T>(ReadOnlySpan<T> x)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            return Aggregate<T, IdentityOperator<T>, MultiplyOperator<T>>(x);
+        }
+
+        /// <summary>Computes the product of the element-wise differences of the numbers in the specified non-empty tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <returns>The result of multiplying the element-wise subtraction of the elements in the second tensor from the first tensor.</returns>
+        /// <exception cref="ArgumentException">Length of both input spans must be greater than zero.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="y"/> must have the same length.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes:
+        /// <c>
+        ///     Span&lt;T&gt; differences = ...;
+        ///     TensorPrimitives.Subtract(x, y, differences);
+        ///     T result = TensorPrimitives.Product(differences);
+        /// </c>
+        /// but without requiring additional temporary storage for the intermediate differences.
+        /// </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 ProductOfDifferences<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
+            where T : ISubtractionOperators<T, T, T>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            return Aggregate<T, SubtractOperator<T>, MultiplyOperator<T>>(x, y);
+        }
+
+        /// <summary>Computes the product of the element-wise sums of the numbers in the specified non-empty tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <returns>The result of multiplying the element-wise additions of the elements in each tensor.</returns>
+        /// <exception cref="ArgumentException">Length of both input spans must be greater than zero.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="y"/> must have the same length.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes:
+        /// <c>
+        ///     Span&lt;T&gt; sums = ...;
+        ///     TensorPrimitives.Add(x, y, sums);
+        ///     T result = TensorPrimitives.Product(sums);
+        /// </c>
+        /// but without requiring additional temporary storage for the intermediate sums.
+        /// </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 ProductOfSums<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            return Aggregate<T, AddOperator<T>, MultiplyOperator<T>>(x, y);
+        }
+
+        /// <summary>Computes the element-wise conversion of each number of radians in the specified tensor to degrees.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.RadiansToDegrees(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void RadiansToDegrees<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, RadiansToDegreesOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise reciprocal of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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>
+        /// <exception cref="DivideByZeroException"><typeparamref name="T"/> is an integer type and an element in <paramref name="x"/> is equal to zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = 1 / <paramref name="x" />[i]</c>.
+        /// </para>
+        /// </remarks>
+        public static void Reciprocal<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPoint<T> =>
+            InvokeSpanIntoSpan<T, ReciprocalOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise reciprocal of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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>
+        /// <exception cref="DivideByZeroException"><typeparamref name="T"/> is an integer type and an element in <paramref name="x"/> is equal to zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = 1 / <paramref name="x" />[i]</c>.
+        /// </para>
+        /// </remarks>
+        public static void ReciprocalEstimate<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanIntoSpan<T, ReciprocalEstimateOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise reciprocal of the square root of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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>
+        /// <exception cref="DivideByZeroException"><typeparamref name="T"/> is an integer type and an element in <paramref name="x"/> is equal to zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = 1 / <paramref name="x" />[i]</c>.
+        /// </para>
+        /// </remarks>
+        public static void ReciprocalSqrt<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanIntoSpan<T, ReciprocalSqrtOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise reciprocal of the square root of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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>
+        /// <exception cref="DivideByZeroException"><typeparamref name="T"/> is an integer type and an element in <paramref name="x"/> is equal to zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = 1 / <paramref name="x" />[i]</c>.
+        /// </para>
+        /// </remarks>
+        public static void ReciprocalSqrtEstimate<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPointIeee754<T> =>
+            InvokeSpanIntoSpan<T, ReciprocalSqrtEstimateOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise rotation right of numbers in the specified tensor by the specified rotation amount.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <param name="n">The degree of the root to be computed, represented as a scalar.</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] = T.RootN(<paramref name="x" />[i], <paramref name="n"/>)</c>.
+        /// </para>
+        /// </remarks>
+        public static void RootN<T>(ReadOnlySpan<T> x, int n, Span<T> destination)
+            where T : IRootFunctions<T>
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            ValidateInputOutputSpanNonOverlapping(x, destination);
+
+            // TODO: Vectorize
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = T.RootN(x[i], n);
+            }
+        }
+
+        /// <summary>Computes the element-wise rotation left of numbers in the specified tensor by the specified rotation amount.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <param name="rotateAmount">The number of bits to rotate, represented as a scalar.</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] = T.RotateLeft(<paramref name="x" />[i], <paramref name="rotateAmount"/>)</c>.
+        /// </para>
+        /// </remarks>
+        public static void RotateLeft<T>(ReadOnlySpan<T> x, int rotateAmount, Span<T> destination)
+            where T : IBinaryInteger<T>
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            ValidateInputOutputSpanNonOverlapping(x, destination);
+
+            // TODO: Vectorize
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = T.RotateLeft(x[i], rotateAmount);
+            }
+        }
+
+        /// <summary>Computes the element-wise rotation right of numbers in the specified tensor by the specified rotation amount.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <param name="rotateAmount">The number of bits to rotate, represented as a scalar.</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] = T.RotateRight(<paramref name="x" />[i], <paramref name="rotateAmount"/>)</c>.
+        /// </para>
+        /// </remarks>
+        public static void RotateRight<T>(ReadOnlySpan<T> x, int rotateAmount, Span<T> destination)
+            where T : IBinaryInteger<T>
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            ValidateInputOutputSpanNonOverlapping(x, destination);
+
+            // TODO: Vectorize
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = T.RotateRight(x[i], rotateAmount);
+            }
+        }
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The tensor, represented as a span.</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] = T.Round(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void Round<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPoint<T> =>
+            Round(x, digits: 0, MidpointRounding.ToEven, destination);
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="mode">The mode under which <paramref name="x" /> should be rounded.</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] = T.Round(<paramref name="x" />[i], <paramref name="mode"/>)</c>.
+        /// </para>
+        /// </remarks>
+        public static void Round<T>(ReadOnlySpan<T> x, MidpointRounding mode, Span<T> destination)
+            where T : IFloatingPoint<T> =>
+            Round(x, digits: 0, mode, destination);
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="digits">The number of fractional digits to which the numbers in <paramref name="x" /> should be rounded.</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] = T.Round(<paramref name="x" />[i], <paramref name="digits"/>)</c>.
+        /// </para>
+        /// </remarks>
+        public static void Round<T>(ReadOnlySpan<T> x, int digits, Span<T> destination) where T : IFloatingPoint<T> =>
+            Round(x, digits, MidpointRounding.ToEven, destination);
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="digits">The number of fractional digits to which the numbers in <paramref name="x" /> should be rounded.</param>
+        /// <param name="mode">The mode under which <paramref name="x" /> should be rounded.</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] = T.Round(<paramref name="x" />[i], <paramref name="digits"/>, <paramref name="mode"/>)</c>.
+        /// </para>
+        /// </remarks>
+        public static void Round<T>(ReadOnlySpan<T> x, int digits, MidpointRounding mode, Span<T> destination)
+            where T : IFloatingPoint<T>
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            ValidateInputOutputSpanNonOverlapping(x, destination);
+
+            // TODO: Vectorize
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = T.Round(x[i], digits, mode);
+            }
+        }
+
+        /// <summary>Computes the element-wise product of numbers in the specified tensor and their base-radix raised to the specified power.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="n">The value to which base-radix is raised before multipliying x, 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] = T.ILogB(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void ScaleB<T>(ReadOnlySpan<T> x, int n, Span<T> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            ValidateInputOutputSpanNonOverlapping(x, destination);
 
-        /// <summary>Computes the product of all elements in the specified non-empty tensor of numbers.</summary>
+            // TODO: Vectorize
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = T.ScaleB(x[i], n);
+            }
+        }
+
+        /// <summary>Computes the element-wise shifting left of numbers in the specified tensor by the specified shift amount.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
-        /// <returns>The result of multiplying all elements in <paramref name="x"/>.</returns>
-        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <param name="shiftAmount">The number of bits to shift, represented as a scalar.</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>
-        /// If any of the input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result value is also NaN.
-        /// </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.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] &lt;&lt; <paramref name="shiftAmount"/></c>.
         /// </para>
         /// </remarks>
-        public static T Product<T>(ReadOnlySpan<T> x)
-            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        public static void ShiftLeft<T>(ReadOnlySpan<T> x, int shiftAmount, Span<T> destination)
+            where T : IBinaryInteger<T>
         {
-            if (x.IsEmpty)
+            if (x.Length > destination.Length)
             {
-                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+                ThrowHelper.ThrowArgument_DestinationTooShort();
             }
 
-            return Aggregate<T, IdentityOperator<T>, MultiplyOperator<T>>(x);
+            ValidateInputOutputSpanNonOverlapping(x, destination);
+
+            // TODO: Vectorize
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = x[i] << shiftAmount;
+            }
         }
 
-        /// <summary>Computes the product of the element-wise differences of the numbers in the specified non-empty tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <returns>The result of multiplying the element-wise subtraction of the elements in the second tensor from the first tensor.</returns>
-        /// <exception cref="ArgumentException">Length of both input spans must be greater than zero.</exception>
-        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="y"/> must have the same length.</exception>
+        /// <summary>Computes the element-wise arithmetic (signed) shifting right of numbers in the specified tensor by the specified shift amount.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <param name="shiftAmount">The number of bits to shift, represented as a scalar.</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>
-        ///     Span&lt;T&gt; differences = ...;
-        ///     TensorPrimitives.Subtract(x, y, differences);
-        ///     T result = TensorPrimitives.Product(differences);
-        /// </c>
-        /// but without requiring additional temporary storage for the intermediate differences.
-        /// </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.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] &gt;&gt; <paramref name="shiftAmount"/></c>.
         /// </para>
         /// </remarks>
-        public static T ProductOfDifferences<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
-            where T : ISubtractionOperators<T, T, T>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        public static void ShiftRightArithmetic<T>(ReadOnlySpan<T> x, int shiftAmount, Span<T> destination)
+            where T : IBinaryInteger<T>
         {
-            if (x.IsEmpty)
+            if (x.Length > destination.Length)
             {
-                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+                ThrowHelper.ThrowArgument_DestinationTooShort();
             }
 
-            return Aggregate<T, SubtractOperator<T>, MultiplyOperator<T>>(x, y);
+            ValidateInputOutputSpanNonOverlapping(x, destination);
+
+            // TODO: Vectorize
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = x[i] >> shiftAmount;
+            }
         }
 
-        /// <summary>Computes the product of the element-wise sums of the numbers in the specified non-empty tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <returns>The result of multiplying the element-wise additions of the elements in each tensor.</returns>
-        /// <exception cref="ArgumentException">Length of both input spans must be greater than zero.</exception>
-        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="y"/> must have the same length.</exception>
+        /// <summary>Computes the element-wise logical (unsigned) shifting right of numbers in the specified tensor by the specified shift amount.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <param name="shiftAmount">The number of bits to shift, represented as a scalar.</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>
-        ///     Span&lt;T&gt; sums = ...;
-        ///     TensorPrimitives.Add(x, y, sums);
-        ///     T result = TensorPrimitives.Product(sums);
-        /// </c>
-        /// but without requiring additional temporary storage for the intermediate sums.
-        /// </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.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] &gt;&gt;&gt; <paramref name="shiftAmount"/></c>.
         /// </para>
         /// </remarks>
-        public static T ProductOfSums<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        public static void ShiftRightLogical<T>(ReadOnlySpan<T> x, int shiftAmount, Span<T> destination)
+            where T : IBinaryInteger<T>
         {
-            if (x.IsEmpty)
+            if (x.Length > destination.Length)
             {
-                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+                ThrowHelper.ThrowArgument_DestinationTooShort();
             }
 
-            return Aggregate<T, AddOperator<T>, MultiplyOperator<T>>(x, y);
+            ValidateInputOutputSpanNonOverlapping(x, destination);
+
+            // TODO: Vectorize
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = x[i] >>> shiftAmount;
+            }
         }
 
         /// <summary>Computes the element-wise sigmoid function on the specified non-empty tensor of numbers.</summary>
@@ -829,7 +2282,7 @@ public static T ProductOfSums<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
         /// <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] = 1f / (1f + <see cref="MathF" />.Exp(-<paramref name="x" />[i]))</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = 1f / (1f + <typeparamref name="T"/>.Exp(-<paramref name="x" />[i]))</c>.
         /// </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
@@ -847,6 +2300,48 @@ public static void Sigmoid<T>(ReadOnlySpan<T> x, Span<T> destination)
             InvokeSpanIntoSpan<T, SigmoidOperator<T>>(x, destination);
         }
 
+        /// <summary>Computes the element-wise sine of the value in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Sin(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi/180 to convert degrees to radians.
+        /// </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 Sin<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, SinOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise sine of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.SinPi(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi/180 to convert degrees to radians.
+        /// </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 SinPi<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, SinPiOperator<T>>(x, destination);
+
         /// <summary>Computes the element-wise hyperbolic sine of each radian angle in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
         /// <param name="destination">The destination tensor, represented as a span.</param>
@@ -854,14 +2349,14 @@ public static void Sigmoid<T>(ReadOnlySpan<T> x, Span<T> destination)
         /// <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] = <see cref="MathF" />.Sinh(<paramref name="x" />[i])</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Sinh(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
         /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>, <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, or <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
         /// the corresponding destination location is set to that value.
         /// </para>
         /// <para>
-        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <see cref="MathF.PI"/>/180 to convert degrees to radians.
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi / 180 to convert degrees to radians.
         /// </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
@@ -872,6 +2367,80 @@ public static void Sinh<T>(ReadOnlySpan<T> x, Span<T> destination)
             where T : IHyperbolicFunctions<T> =>
             InvokeSpanIntoSpan<T, SinhOperator<T>>(x, destination);
 
+        /// <summary>Computes the element-wise sine and cosine of the value in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="sinDestination">The destination tensor for the element-wise sine result, represented as a span.</param>
+        /// <param name="cosDestination">The destination tensor for the element-wise cosine result, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="sinDestination"/> or <paramref name="cosDestination" /> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c>(<paramref name="sinDestination" />[i], <paramref name="cosDestination" />[i]) = <typeparamref name="T"/>.SinCos(<paramref name="x" />[i])</c>.
+        /// </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 SinCos<T>(ReadOnlySpan<T> x, Span<T> sinDestination, Span<T> cosDestination)
+            where T : ITrigonometricFunctions<T>
+        {
+            if (x.Length > sinDestination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort(nameof(sinDestination));
+            }
+            if (x.Length > cosDestination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort(nameof(cosDestination));
+            }
+
+            ValidateInputOutputSpanNonOverlapping(x, sinDestination);
+            ValidateInputOutputSpanNonOverlapping(x, cosDestination);
+
+            // TODO: Vectorize
+            for (int i = 0; i < x.Length; i++)
+            {
+                (sinDestination[i], cosDestination[i]) = T.SinCos(x[i]);
+            }
+        }
+
+        /// <summary>Computes the element-wise sine and cosine of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="sinPiDestination">The destination tensor for the element-wise sine result, represented as a span.</param>
+        /// <param name="cosPiDestination">The destination tensor for the element-wise cosine result, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="sinPiDestination"/> or <paramref name="cosPiDestination" /> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c>(<paramref name="sinPiDestination" />[i], <paramref name="cosPiDestination" />[i]) = <typeparamref name="T"/>.SinCos(<paramref name="x" />[i])</c>.
+        /// </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 SinCosPi<T>(ReadOnlySpan<T> x, Span<T> sinPiDestination, Span<T> cosPiDestination)
+            where T : ITrigonometricFunctions<T>
+        {
+            if (x.Length > sinPiDestination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort(nameof(sinPiDestination));
+            }
+            if (x.Length > cosPiDestination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort(nameof(cosPiDestination));
+            }
+
+            ValidateInputOutputSpanNonOverlapping(x, sinPiDestination);
+            ValidateInputOutputSpanNonOverlapping(x, cosPiDestination);
+
+            // TODO: Vectorize
+            for (int i = 0; i < x.Length; i++)
+            {
+                (sinPiDestination[i], cosPiDestination[i]) = T.SinCosPi(x[i]);
+            }
+        }
+
         /// <summary>Computes the softmax function over the specified non-empty tensor of numbers.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
         /// <param name="destination">The destination tensor.</param>
@@ -880,8 +2449,8 @@ public static void Sinh<T>(ReadOnlySpan<T> x, Span<T> destination)
         /// <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 a sum of <c>MathF.Exp(x[i])</c> for all elements in <paramref name="x"/>.
-        /// It then effectively computes <c><paramref name="destination" />[i] = MathF.Exp(<paramref name="x" />[i]) / sum</c>.
+        /// This method effectively computes a sum of <c><typeparamref name="T"/>.Exp(x[i])</c> for all elements in <paramref name="x"/>.
+        /// It then effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Exp(<paramref name="x" />[i]) / sum</c>.
         /// </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
@@ -908,6 +2477,20 @@ public static void SoftMax<T>(ReadOnlySpan<T> x, Span<T> destination)
             InvokeSpanScalarIntoSpan<T, ExpOperator<T>, DivideOperator<T>>(x, expSum, destination);
         }
 
+        /// <summary>Computes the element-wise square root of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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] = T.Sqrt(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void Sqrt<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IRootFunctions<T> =>
+            InvokeSpanIntoSpan<T, SqrtOperator<T>>(x, destination);
+
         /// <summary>Computes the element-wise difference between numbers 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>
@@ -946,6 +2529,24 @@ public static void Subtract<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
             where T : ISubtractionOperators<T, T, T> =>
             InvokeSpanScalarIntoSpan<T, SubtractOperator<T>>(x, y, destination);
 
+        /// <summary>Computes the element-wise difference between numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a scalar.</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">Destination is too short.</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] = <paramref name="x" /> - <paramref name="y" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Subtract<T>(T x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : ISubtractionOperators<T, T, T> =>
+            InvokeScalarSpanIntoSpan<T, SubtractOperator<T>>(x, y, destination);
+
         /// <summary>Computes the sum of all elements in the specified tensor of numbers.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
         /// <returns>The result of adding all elements in <paramref name="x"/>, or zero if <paramref name="x"/> is empty.</returns>
@@ -1007,6 +2608,48 @@ public static T SumOfSquares<T>(ReadOnlySpan<T> x)
             where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T> =>
             Aggregate<T, SquaredOperator<T>, AddOperator<T>>(x);
 
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.Tan(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi/180 to convert degrees to radians.
+        /// </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 Tan<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, TanOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="x">The tensor, represented as a span.</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"/>.TanPi(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi/180 to convert degrees to radians.
+        /// </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 TanPi<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ITrigonometricFunctions<T> =>
+            InvokeSpanIntoSpan<T, TanPiOperator<T>>(x, destination);
+
         /// <summary>Computes the element-wise hyperbolic tangent of each radian angle in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
         /// <param name="destination">The destination tensor, represented as a span.</param>
@@ -1014,7 +2657,7 @@ public static T SumOfSquares<T>(ReadOnlySpan<T> x)
         /// <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] = <see cref="MathF" />.Tanh(<paramref name="x" />[i])</c>.
+        /// This method effectively computes <c><paramref name="destination" />[i] = <typeparamref name="T"/>.Tanh(<paramref name="x" />[i])</c>.
         /// </para>
         /// <para>
         /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>, the corresponding destination location is set to -1.
@@ -1022,7 +2665,7 @@ public static T SumOfSquares<T>(ReadOnlySpan<T> x)
         /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the corresponding destination location is set to NaN.
         /// </para>
         /// <para>
-        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <see cref="MathF.PI"/>/180 to convert degrees to radians.
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi / 180 to convert degrees to radians.
         /// </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
@@ -1032,5 +2675,65 @@ public static T SumOfSquares<T>(ReadOnlySpan<T> x)
         public static void Tanh<T>(ReadOnlySpan<T> x, Span<T> destination)
             where T : IHyperbolicFunctions<T> =>
             InvokeSpanIntoSpan<T, TanhOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise trailing zero count of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</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] = T.TrailingZeroCount(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void TrailingZeroCount<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IBinaryInteger<T> =>
+            InvokeSpanIntoSpan<T, TrailingZeroCountOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise truncation of numbers in the specified tensor.</summary>
+        /// <param name="x">The first tensor, represented as a span.</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] = T.Truncate(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void Truncate<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IFloatingPoint<T> =>
+            InvokeSpanIntoSpan<T, TruncateOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise XOR of numbers 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] = <paramref name="x" />[i] ^ <paramref name="y" />[i]</c>.
+        /// </para>
+        /// </remarks>
+        public static void Xor<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IBitwiseOperators<T, T, T> =>
+            InvokeSpanSpanIntoSpan<T, XorOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise XOR of numbers 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] = <paramref name="x" />[i] ^ <paramref name="y" /></c>.
+        /// </para>
+        /// </remarks>
+        public static void Xor<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : IBitwiseOperators<T, T, T> =>
+            InvokeSpanScalarIntoSpan<T, XorOperator<T>>(x, y, destination);
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.netcore.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.netcore.cs
index 41560fbb8b284f..1550e3d6bf7d4c 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.netcore.cs
@@ -11,9 +11,8 @@
 #pragma warning disable CS8500 // This takes the address of, gets the size of, or declares a pointer to a managed type
 
 // TODO:
-// - Vectorize the trig-related functions for Ts other than floats
+// - Vectorize remaining trig-related functions (some aren't vectorized at all, some are only vectorized for float).
 // - Vectorize integer operations when sizeof(T) == 1 or 2 (currently only vectorized in most operations for sizeof(T) == 4 or 8).
-// - Implement generic version of IndexOfMinMaxCore and corresponding IndexOf methods.
 
 namespace System.Numerics.Tensors
 {
@@ -1624,7 +1623,7 @@ private static T Aggregate<T, TBinaryOperator, TAggregationOperator>(
 
             nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TBinaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
                 T result;
 
@@ -1644,7 +1643,7 @@ private static T Aggregate<T, TBinaryOperator, TAggregationOperator>(
                 return result;
             }
 
-            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TBinaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
                 T result;
 
@@ -1664,7 +1663,7 @@ private static T Aggregate<T, TBinaryOperator, TAggregationOperator>(
                 return result;
             }
 
-            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && TBinaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
                 T result;
 
@@ -2724,8 +2723,9 @@ private static T MinMaxCore<T, TMinMaxOperator>(ReadOnlySpan<T> x)
             return curResult;
         }
 
-        private static int IndexOfMinMaxCore<TIndexOfMinMax>(ReadOnlySpan<float> x)
-            where TIndexOfMinMax : struct, IIndexOfOperator
+        private static int IndexOfMinMaxCore<T, TIndexOfMinMax>(ReadOnlySpan<T> x)
+            where T : INumber<T>
+            where TIndexOfMinMax : struct, IIndexOfOperator<T>
         {
             if (x.IsEmpty)
             {
@@ -2737,193 +2737,270 @@ private static int IndexOfMinMaxCore<TIndexOfMinMax>(ReadOnlySpan<float> x)
             // otherwise returns the index of the greater of the inputs.
             // It treats +0 as greater than -0 as per the specification.
 
-            if (Vector512.IsHardwareAccelerated && x.Length >= Vector512<float>.Count)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count)
             {
-                ref float xRef = ref MemoryMarshal.GetReference(x);
-                Vector512<int> resultIndex = Vector512.Create(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
-                Vector512<int> curIndex = resultIndex;
-                Vector512<int> increment = Vector512.Create(Vector512<float>.Count);
+                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.Create(0L, 1, 2, 3, 4, 5, 6, 7).As<long, T>() :
+                    sizeof(T) == sizeof(int) ? Vector512.Create(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15).As<int, T>() :
+                    sizeof(T) == sizeof(short) ? Vector512.Create(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31).As<short, T>() :
+                    Vector512.Create((byte)0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63).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<float> result = Vector512.LoadUnsafe(ref xRef);
-                Vector512<float> current;
+                Vector512<T> result = Vector512.LoadUnsafe(ref xRef);
+                Vector512<T> current;
 
-                Vector512<float> nanMask = ~Vector512.Equals(result, result);
-                if (nanMask != Vector512<float>.Zero)
+                Vector512<T> nanMask;
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                 {
-                    return IndexOfFirstMatch(nanMask);
+                    nanMask = ~Vector512.Equals(result, result);
+                    if (nanMask != Vector512<T>.Zero)
+                    {
+                        return IndexOfFirstMatch(nanMask);
+                    }
                 }
 
-                int oneVectorFromEnd = x.Length - Vector512<float>.Count;
-                int i = Vector512<float>.Count;
+                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)
                 {
                     // Load the next vector, and early exit on NaN.
                     current = Vector512.LoadUnsafe(ref xRef, (uint)i);
-                    curIndex += increment;
+                    currentIndex += increment;
 
-                    nanMask = ~Vector512.Equals(current, current);
-                    if (nanMask != Vector512<float>.Zero)
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return i + IndexOfFirstMatch(nanMask);
+                        nanMask = ~Vector512.Equals(current, current);
+                        if (nanMask != Vector512<T>.Zero)
+                        {
+                            return i + IndexOfFirstMatch(nanMask);
+                        }
                     }
 
-                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, curIndex);
+                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
 
-                    i += Vector512<float>.Count;
+                    i += Vector512<T>.Count;
                 }
 
                 // If any elements remain, handle them in one final vector.
                 if (i != x.Length)
                 {
-                    current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<float>.Count));
-                    curIndex += Vector512.Create(x.Length - i);
+                    current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count));
+                    currentIndex += CreateVector512T(x.Length - i);
 
-                    nanMask = ~Vector512.Equals(current, current);
-                    if (nanMask != Vector512<float>.Zero)
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return curIndex[IndexOfFirstMatch(nanMask)];
+                        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, curIndex);
+                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
                 }
 
                 // Aggregate the lanes in the vector to create the final scalar result.
-                return TIndexOfMinMax.Invoke(result, resultIndex);
+                return IndexOfFinalAggregate<T, TIndexOfMinMax>(result, resultIndex);
             }
 
-            if (Vector256.IsHardwareAccelerated && x.Length >= Vector256<float>.Count)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count)
             {
-                ref float xRef = ref MemoryMarshal.GetReference(x);
-                Vector256<int> resultIndex = Vector256.Create(0, 1, 2, 3, 4, 5, 6, 7);
-                Vector256<int> curIndex = resultIndex;
-                Vector256<int> increment = Vector256.Create(Vector256<float>.Count);
+                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.Create(0L, 1, 2, 3).As<long, T>() :
+                    sizeof(T) == sizeof(int) ? Vector256.Create(0, 1, 2, 3, 4, 5, 6, 7).As<int, T>() :
+                    sizeof(T) == sizeof(short) ? Vector256.Create(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15).As<short, T>() :
+                    Vector256.Create((byte)0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31).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<float> result = Vector256.LoadUnsafe(ref xRef);
-                Vector256<float> current;
+                Vector256<T> result = Vector256.LoadUnsafe(ref xRef);
+                Vector256<T> current;
 
-                Vector256<float> nanMask = ~Vector256.Equals(result, result);
-                if (nanMask != Vector256<float>.Zero)
+                Vector256<T> nanMask;
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                 {
-                    return IndexOfFirstMatch(nanMask);
+                    nanMask = ~Vector256.Equals(result, result);
+                    if (nanMask != Vector256<T>.Zero)
+                    {
+                        return IndexOfFirstMatch(nanMask);
+                    }
                 }
 
-                int oneVectorFromEnd = x.Length - Vector256<float>.Count;
-                int i = Vector256<float>.Count;
+                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)
                 {
                     // Load the next vector, and early exit on NaN.
                     current = Vector256.LoadUnsafe(ref xRef, (uint)i);
-                    curIndex += increment;
+                    currentIndex += increment;
 
-                    nanMask = ~Vector256.Equals(current, current);
-                    if (nanMask != Vector256<float>.Zero)
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return i + IndexOfFirstMatch(nanMask);
+                        nanMask = ~Vector256.Equals(current, current);
+                        if (nanMask != Vector256<T>.Zero)
+                        {
+                            return i + IndexOfFirstMatch(nanMask);
+                        }
                     }
 
-                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, curIndex);
+                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
 
-                    i += Vector256<float>.Count;
+                    i += Vector256<T>.Count;
                 }
 
                 // If any elements remain, handle them in one final vector.
                 if (i != x.Length)
                 {
-                    current = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<float>.Count));
-                    curIndex += Vector256.Create(x.Length - i);
+                    current = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count));
+                    currentIndex += CreateVector256T(x.Length - i);
 
-                    nanMask = ~Vector256.Equals(current, current);
-                    if (nanMask != Vector256<float>.Zero)
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return curIndex[IndexOfFirstMatch(nanMask)];
+                        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, curIndex);
+                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
                 }
 
                 // Aggregate the lanes in the vector to create the final scalar result.
-                return TIndexOfMinMax.Invoke(result, resultIndex);
+                return IndexOfFinalAggregate<T, TIndexOfMinMax>(result, resultIndex);
             }
 
-            if (Vector128.IsHardwareAccelerated && x.Length >= Vector128<float>.Count)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && x.Length >= Vector128<T>.Count)
             {
-                ref float xRef = ref MemoryMarshal.GetReference(x);
-                Vector128<int> resultIndex = Vector128.Create(0, 1, 2, 3);
-                Vector128<int> curIndex = resultIndex;
-                Vector128<int> increment = Vector128.Create(Vector128<float>.Count);
+                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.Create(0L, 1).As<long, T>() :
+                    sizeof(T) == sizeof(int) ? Vector128.Create(0, 1, 2, 3).As<int, T>() :
+                    sizeof(T) == sizeof(short) ? Vector128.Create(0, 1, 2, 3, 4, 5, 6, 7).As<short, T>() :
+                    Vector128.Create((byte)0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15).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<float> result = Vector128.LoadUnsafe(ref xRef);
-                Vector128<float> current;
+                Vector128<T> result = Vector128.LoadUnsafe(ref xRef);
+                Vector128<T> current;
 
-                Vector128<float> nanMask = ~Vector128.Equals(result, result);
-                if (nanMask != Vector128<float>.Zero)
+                Vector128<T> nanMask;
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                 {
-                    return IndexOfFirstMatch(nanMask);
+                    nanMask = ~Vector128.Equals(result, result);
+                    if (nanMask != Vector128<T>.Zero)
+                    {
+                        return IndexOfFirstMatch(nanMask);
+                    }
                 }
 
-                int oneVectorFromEnd = x.Length - Vector128<float>.Count;
-                int i = Vector128<float>.Count;
+                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)
                 {
                     // Load the next vector, and early exit on NaN.
                     current = Vector128.LoadUnsafe(ref xRef, (uint)i);
-                    curIndex += increment;
+                    currentIndex += increment;
 
-                    nanMask = ~Vector128.Equals(current, current);
-                    if (nanMask != Vector128<float>.Zero)
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return i + IndexOfFirstMatch(nanMask);
+                        nanMask = ~Vector128.Equals(current, current);
+                        if (nanMask != Vector128<T>.Zero)
+                        {
+                            return i + IndexOfFirstMatch(nanMask);
+                        }
                     }
 
-                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, curIndex);
+                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
 
-                    i += Vector128<float>.Count;
+                    i += Vector128<T>.Count;
                 }
 
                 // If any elements remain, handle them in one final vector.
                 if (i != x.Length)
                 {
-                    curIndex += Vector128.Create(x.Length - i);
-
-                    current = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<float>.Count));
+                    current = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<T>.Count));
+                    currentIndex += CreateVector128T(x.Length - i);
 
-                    nanMask = ~Vector128.Equals(current, current);
-                    if (nanMask != Vector128<float>.Zero)
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return curIndex[IndexOfFirstMatch(nanMask)];
+                        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, curIndex);
+                    TIndexOfMinMax.Invoke(ref result, current, ref resultIndex, currentIndex);
                 }
 
                 // Aggregate the lanes in the vector to create the final scalar result.
-                return TIndexOfMinMax.Invoke(result, resultIndex);
+                return IndexOfFinalAggregate<T, TIndexOfMinMax>(result, resultIndex);
             }
 
             // Scalar path used when either vectorization is not supported or the input is too small to vectorize.
-            float curResult = x[0];
+            T curResult = x[0];
             int curIn = 0;
-            if (float.IsNaN(curResult))
+            if (T.IsNaN(curResult))
             {
                 return curIn;
             }
 
             for (int i = 1; i < x.Length; i++)
             {
-                float current = x[i];
-                if (float.IsNaN(current))
+                T current = x[i];
+                if (T.IsNaN(current))
                 {
                     return i;
                 }
@@ -2934,20 +3011,14 @@ private static int IndexOfMinMaxCore<TIndexOfMinMax>(ReadOnlySpan<float> x)
             return curIn;
         }
 
-        private static int IndexOfFirstMatch<T>(Vector128<T> mask)
-        {
-            return BitOperations.TrailingZeroCount(mask.ExtractMostSignificantBits());
-        }
+        private static int IndexOfFirstMatch<T>(Vector128<T> mask) =>
+            BitOperations.TrailingZeroCount(mask.ExtractMostSignificantBits());
 
-        private static int IndexOfFirstMatch<T>(Vector256<T> mask)
-        {
-            return BitOperations.TrailingZeroCount(mask.ExtractMostSignificantBits());
-        }
+        private static int IndexOfFirstMatch<T>(Vector256<T> mask) =>
+            BitOperations.TrailingZeroCount(mask.ExtractMostSignificantBits());
 
-        private static int IndexOfFirstMatch<T>(Vector512<T> mask)
-        {
-            return BitOperations.TrailingZeroCount(mask.ExtractMostSignificantBits());
-        }
+        private static int IndexOfFirstMatch<T>(Vector512<T> mask) =>
+            BitOperations.TrailingZeroCount(mask.ExtractMostSignificantBits());
 
         /// <summary>Performs an element-wise operation on <paramref name="x"/> and writes the results to <paramref name="destination"/>.</summary>
         /// <typeparam name="T">The element type.</typeparam>
@@ -3879,7 +3950,7 @@ private static void InvokeSpanSpanIntoSpan<T, TBinaryOperator>(
 
             nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TBinaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
                 if (remainder >= (uint)Vector512<T>.Count)
                 {
@@ -3897,7 +3968,7 @@ private static void InvokeSpanSpanIntoSpan<T, TBinaryOperator>(
                 return;
             }
 
-            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TBinaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
                 if (remainder >= (uint)Vector256<T>.Count)
                 {
@@ -3915,7 +3986,7 @@ private static void InvokeSpanSpanIntoSpan<T, TBinaryOperator>(
                 return;
             }
 
-            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && TBinaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
                 if (remainder >= (uint)Vector128<T>.Count)
                 {
@@ -4857,6 +4928,19 @@ static void VectorizedSmall8(ref T xRef, ref T yRef, ref T dRef, nuint remainder
             }
         }
 
+        /// <summary>
+        /// Performs an element-wise operation on <paramref name="x"/> and <paramref name="y"/>,
+        /// and writes the results to <paramref name="destination"/>.
+        /// </summary>
+        /// <typeparam name="T">The element type.</typeparam>
+        /// <typeparam name="TBinaryOperator">
+        /// Specifies the operation to perform on each element loaded from <paramref name="x"/> with <paramref name="y"/>.
+        /// </typeparam>
+        private static void InvokeScalarSpanIntoSpan<T, TBinaryOperator>(
+            T x, ReadOnlySpan<T> y, Span<T> destination)
+            where TBinaryOperator : struct, IBinaryOperator<T> =>
+            InvokeSpanScalarIntoSpan<T, IdentityOperator<T>, InvertedBinaryOperator<TBinaryOperator, T>>(y, x, destination);
+
         /// <summary>
         /// Performs an element-wise operation on <paramref name="x"/> and <paramref name="y"/>,
         /// and writes the results to <paramref name="destination"/>.
@@ -4904,7 +4988,7 @@ private static void InvokeSpanScalarIntoSpan<T, TTransformOperator, TBinaryOpera
 
             nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TTransformOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TTransformOperator.Vectorizable && TBinaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
                 if (remainder >= (uint)Vector512<T>.Count)
                 {
@@ -4922,7 +5006,7 @@ private static void InvokeSpanScalarIntoSpan<T, TTransformOperator, TBinaryOpera
                 return;
             }
 
-            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TTransformOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TTransformOperator.Vectorizable && TBinaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
                 if (remainder >= (uint)Vector256<T>.Count)
                 {
@@ -4940,7 +5024,7 @@ private static void InvokeSpanScalarIntoSpan<T, TTransformOperator, TBinaryOpera
                 return;
             }
 
-            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && TTransformOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && TTransformOperator.Vectorizable && TBinaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
                 if (remainder >= (uint)Vector128<T>.Count)
                 {
@@ -9417,24 +9501,6 @@ private static Vector512<T> IsNegative<T>(Vector512<T> vector)
             return Vector512.LessThan(vector, Vector512<T>.Zero);
         }
 
-        /// <summary>Gets whether the specified <see cref="float"/> is positive.</summary>
-        private static bool IsPositive(float f) => float.IsPositive(f);
-
-        /// <summary>Gets whether each specified <see cref="float"/> is positive.</summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector128<float> IsPositive(Vector128<float> vector) =>
-            Vector128.GreaterThan(vector.AsInt32(), Vector128<int>.AllBitsSet).AsSingle();
-
-        /// <summary>Gets whether each specified <see cref="float"/> is positive.</summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector256<float> IsPositive(Vector256<float> vector) =>
-            Vector256.GreaterThan(vector.AsInt32(), Vector256<int>.AllBitsSet).AsSingle();
-
-        /// <summary>Gets whether each specified <see cref="float"/> is positive.</summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector512<float> IsPositive(Vector512<float> vector) =>
-            Vector512.GreaterThan(vector.AsInt32(), Vector512<int>.AllBitsSet).AsSingle();
-
         /// <summary>
         /// Gets a vector mask that will be all-ones-set for the last <paramref name="count"/> elements
         /// and zero for all other elements.
@@ -9672,6 +9738,8 @@ ref Unsafe.As<ulong, T>(ref MemoryMarshal.GetReference(RemainderUInt64Mask_8x9))
         /// <summary>x + y</summary>
         internal readonly struct AddOperator<T> : IAggregationOperator<T> where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
         {
+            public static bool Vectorizable => true;
+
             public static T Invoke(T x, T y) => x + y;
             public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x + y;
             public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x + y;
@@ -9684,9 +9752,20 @@ ref Unsafe.As<ulong, T>(ref MemoryMarshal.GetReference(RemainderUInt64Mask_8x9))
             public static T IdentityValue => T.AdditiveIdentity;
         }
 
+        private readonly struct InvertedBinaryOperator<TOperator, T> : IBinaryOperator<T>
+            where TOperator : IBinaryOperator<T>
+        {
+            public static bool Vectorizable => TOperator.Vectorizable;
+            public static T Invoke(T x, T y) => TOperator.Invoke(y, x);
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => TOperator.Invoke(y, x);
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => TOperator.Invoke(y, x);
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => TOperator.Invoke(y, x);
+        }
+
         /// <summary>x - y</summary>
         internal readonly struct SubtractOperator<T> : IBinaryOperator<T> where T : ISubtractionOperators<T, T, T>
         {
+            public static bool Vectorizable => true;
             public static T Invoke(T x, T y) => x - y;
             public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x - y;
             public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x - y;
@@ -9696,6 +9775,8 @@ ref Unsafe.As<ulong, T>(ref MemoryMarshal.GetReference(RemainderUInt64Mask_8x9))
         /// <summary>(x - y) * (x - y)</summary>
         internal readonly struct SubtractSquaredOperator<T> : IBinaryOperator<T> where T : ISubtractionOperators<T, T, T>, IMultiplyOperators<T, T, T>
         {
+            public static bool Vectorizable => true;
+
             public static T Invoke(T x, T y)
             {
                 T tmp = x - y;
@@ -9724,6 +9805,8 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         /// <summary>x * y</summary>
         internal readonly struct MultiplyOperator<T> : IAggregationOperator<T> where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
         {
+            public static bool Vectorizable => true;
+
             public static T Invoke(T x, T y) => x * y;
             public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x * y;
             public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x * y;
@@ -9739,15 +9822,200 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         /// <summary>x / y</summary>
         internal readonly struct DivideOperator<T> : IBinaryOperator<T> where T : IDivisionOperators<T, T, T>
         {
+            public static bool Vectorizable => true;
             public static T Invoke(T x, T y) => x / y;
             public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x / y;
             public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x / y;
             public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x / y;
         }
 
+        /// <summary>T.Ieee754Remainder(x, y)</summary>
+        internal readonly struct Ieee754RemainderOperator<T> : IBinaryOperator<T> where T : IFloatingPointIeee754<T>
+        {
+            public static bool Vectorizable => false;
+            public static T Invoke(T x, T y) => T.Ieee754Remainder(x, y);
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => throw new NotSupportedException();
+        }
+
+        // Ieee754Remainder
+
+        internal readonly struct ReciprocalOperator<T> : IUnaryOperator<T> where T : IFloatingPoint<T>
+        {
+            public static bool Vectorizable => true;
+            public static T Invoke(T x) => T.One / x;
+            public static Vector128<T> Invoke(Vector128<T> x) => Vector128<T>.One / x;
+            public static Vector256<T> Invoke(Vector256<T> x) => Vector256<T>.One / x;
+            public static Vector512<T> Invoke(Vector512<T> x) => Vector512<T>.One / x;
+        }
+
+        private readonly struct ReciprocalSqrtOperator<T> : IUnaryOperator<T> where T : IFloatingPointIeee754<T>
+        {
+            public static bool Vectorizable => true;
+            public static T Invoke(T x) => T.One / T.Sqrt(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => Vector128<T>.One / Vector128.Sqrt(x);
+            public static Vector256<T> Invoke(Vector256<T> x) => Vector256<T>.One / Vector256.Sqrt(x);
+            public static Vector512<T> Invoke(Vector512<T> x) => Vector512<T>.One / Vector512.Sqrt(x);
+        }
+
+        private readonly struct ReciprocalEstimateOperator<T> : IUnaryOperator<T> where T : IFloatingPointIeee754<T>
+        {
+            public static bool Vectorizable => true;
+
+            public static T Invoke(T x) => T.ReciprocalEstimate(x);
+
+            public static Vector128<T> Invoke(Vector128<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    if (Sse.IsSupported)
+                    {
+                        return Sse.Reciprocal(x.AsSingle()).As<float, T>();
+                    }
+
+                    if (AdvSimd.IsSupported)
+                    {
+                        return AdvSimd.ReciprocalEstimate(x.AsSingle()).As<float, T>();
+                    }
+                }
+
+                return Vector128<T>.One / x;
+            }
+
+            public static Vector256<T> Invoke(Vector256<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    if (Avx.IsSupported)
+                    {
+                        return Avx.Reciprocal(x.AsSingle()).As<float, T>();
+                    }
+                }
+
+                return Vector256<T>.One / x;
+            }
+
+            public static Vector512<T> Invoke(Vector512<T> x)
+            {
+                if (Avx512F.IsSupported)
+                {
+                    if (typeof(T) == typeof(float))
+                    {
+                        return Avx512F.Reciprocal14(x.AsSingle()).As<float, T>();
+                    }
+
+                    if (typeof(T) == typeof(double))
+                    {
+                        return Avx512F.Reciprocal14(x.AsDouble()).As<double, T>();
+                    }
+                }
+
+                return Vector512<T>.One / x;
+            }
+        }
+
+        private readonly struct ReciprocalSqrtEstimateOperator<T> : IUnaryOperator<T> where T : IFloatingPointIeee754<T>
+        {
+            public static bool Vectorizable => true;
+
+            public static T Invoke(T x) => T.ReciprocalSqrtEstimate(x);
+
+            public static Vector128<T> Invoke(Vector128<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    if (Sse.IsSupported)
+                    {
+                        return Sse.ReciprocalSqrt(x.AsSingle()).As<float, T>();
+                    }
+
+                    if (AdvSimd.IsSupported)
+                    {
+                        return AdvSimd.ReciprocalSquareRootEstimate(x.AsSingle()).As<float, T>();
+                    }
+                }
+
+                return Vector128<T>.One / Vector128.Sqrt(x);
+            }
+
+            public static Vector256<T> Invoke(Vector256<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    if (Avx.IsSupported)
+                    {
+                        return Avx.ReciprocalSqrt(x.AsSingle()).As<float, T>();
+                    }
+                }
+
+                return Vector256<T>.One / Vector256.Sqrt(x);
+            }
+
+            public static Vector512<T> Invoke(Vector512<T> x)
+            {
+                if (Avx512F.IsSupported)
+                {
+                    if (typeof(T) == typeof(float))
+                    {
+                        return Avx512F.ReciprocalSqrt14(x.AsSingle()).As<float, T>();
+                    }
+
+                    if (typeof(T) == typeof(double))
+                    {
+                        return Avx512F.ReciprocalSqrt14(x.AsDouble()).As<double, T>();
+                    }
+                }
+
+                return Vector512<T>.One / Vector512.Sqrt(x);
+            }
+        }
+
+        /// <summary>x &amp; y</summary>
+        internal readonly struct BitwiseAndOperator<T> : IBinaryOperator<T> where T : IBitwiseOperators<T, T, T>
+        {
+            public static bool Vectorizable => true;
+            public static T Invoke(T x, T y) => x & y;
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x & y;
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x & y;
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x & y;
+        }
+
+        /// <summary>x | y</summary>
+        internal readonly struct BitwiseOrOperator<T> : IBinaryOperator<T> where T : IBitwiseOperators<T, T, T>
+        {
+            public static bool Vectorizable => true;
+            public static T Invoke(T x, T y) => x | y;
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x | y;
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x | y;
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x | y;
+        }
+
+        /// <summary>x ^ y</summary>
+        internal readonly struct XorOperator<T> : IBinaryOperator<T> where T : IBitwiseOperators<T, T, T>
+        {
+            public static bool Vectorizable => true;
+            public static T Invoke(T x, T y) => x ^ y;
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x ^ y;
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x ^ y;
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x ^ y;
+        }
+
+        /// <summary>~x</summary>
+        internal readonly struct OnesComplementOperator<T> : IUnaryOperator<T> where T : IBitwiseOperators<T, T, T>
+        {
+            public static bool Vectorizable => true;
+            public static T Invoke(T x) => ~x;
+            public static Vector128<T> Invoke(Vector128<T> x) => ~x;
+            public static Vector256<T> Invoke(Vector256<T> x) => ~x;
+            public static Vector512<T> Invoke(Vector512<T> x) => ~x;
+        }
+
         /// <summary>T.Max(x, y) (but NaNs may not be propagated)</summary>
         internal readonly struct MaxOperator<T> : IAggregationOperator<T> where T : INumber<T>
         {
+            public static bool Vectorizable => true;
+
             public static T Invoke(T x, T y)
             {
                 if (typeof(T) == typeof(Half) || typeof(T) == typeof(float) || typeof(T) == typeof(double))
@@ -9842,256 +10110,350 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
             public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x);
         }
 
-        private interface IIndexOfOperator
+        private interface IIndexOfOperator<T> where T : INumber<T>
         {
-            static abstract int Invoke(ref float result, float current, int resultIndex, int curIndex);
-            static abstract int Invoke(Vector128<float> result, Vector128<int> resultIndex);
-            static abstract void Invoke(ref Vector128<float> result, Vector128<float> current, ref Vector128<int> resultIndex, Vector128<int> curIndex);
-            static abstract int Invoke(Vector256<float> result, Vector256<int> resultIndex);
-            static abstract void Invoke(ref Vector256<float> result, Vector256<float> current, ref Vector256<int> resultIndex, Vector256<int> curIndex);
-            static abstract int Invoke(Vector512<float> result, Vector512<int> resultIndex);
-            static abstract void Invoke(ref Vector512<float> result, Vector512<float> current, ref Vector512<int> resultIndex, Vector512<int> curIndex);
+            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);
         }
 
-        /// <summary>Returns the index of MathF.Max(x, y)</summary>
-        internal readonly struct IndexOfMaxOperator : IIndexOfOperator
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int IndexOfFinalAggregate<T, TIndexOfOperator>(Vector128<T> result, Vector128<T> resultIndex)
+            where T : INumber<T>
+            where TIndexOfOperator : struct, IIndexOfOperator<T>
         {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector128<float> result, Vector128<int> maxIndex)
-            {
-                Vector128<float> tmpResult;
-                Vector128<int> tmpIndex;
-
-                tmpResult = Vector128.Shuffle(result, Vector128.Create(2, 3, 0, 1));
-                tmpIndex = Vector128.Shuffle(maxIndex, Vector128.Create(2, 3, 0, 1));
-                Invoke(ref result, tmpResult, ref maxIndex, tmpIndex);
+            Vector128<T> tmpResult;
+            Vector128<T> tmpIndex;
 
-                tmpResult = Vector128.Shuffle(result, Vector128.Create(1, 0, 3, 2));
-                tmpIndex = Vector128.Shuffle(maxIndex, Vector128.Create(1, 0, 3, 2));
-                Invoke(ref result, tmpResult, ref maxIndex, tmpIndex);
+            if (sizeof(T) == 8)
+            {
+                // 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);
 
-                return maxIndex.ToScalar();
+                // Return 0
+                return (int)resultIndex.As<T, long>().ToScalar();
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector128<float> max, Vector128<float> current, ref Vector128<int> maxIndex, Vector128<int> curIndex)
+            if (sizeof(T) == 4)
             {
-                Vector128<float> greaterThanMask = Vector128.GreaterThan(max, current);
-
-                Vector128<float> equalMask = Vector128.Equals(max, current);
-                if (equalMask.AsInt32() != Vector128<int>.Zero)
-                {
-                    Vector128<float> negativeMask = IsNegative(current);
-                    Vector128<int> lessThanMask = Vector128.LessThan(maxIndex, curIndex);
+                // 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);
 
-                    greaterThanMask |= (negativeMask & equalMask) | (~IsNegative(max) & equalMask & lessThanMask.AsSingle());
-                }
-
-                max = ElementWiseSelect(greaterThanMask, max, current);
+                // 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);
 
-                maxIndex = ElementWiseSelect(greaterThanMask.AsInt32(), maxIndex, curIndex);
+                // Return 0
+                return resultIndex.As<T, int>().ToScalar();
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector256<float> result, Vector256<int> maxIndex)
+            if (sizeof(T) == 2)
             {
-                // Max the upper/lower halves of the Vector256
-                Vector128<float> resultLower = result.GetLower();
-                Vector128<int> indexLower = maxIndex.GetLower();
+                // 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);
+
+                // 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);
 
-                Invoke(ref resultLower, result.GetUpper(), ref indexLower, maxIndex.GetUpper());
-                return Invoke(resultLower, indexLower);
+                // 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);
+
+                // Return 0
+                return resultIndex.As<T, short>().ToScalar();
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector256<float> max, Vector256<float> current, ref Vector256<int> maxIndex, Vector256<int> curIndex)
+            if (sizeof(T) == 1)
             {
-                Vector256<float> greaterThanMask = Vector256.GreaterThan(max, current);
+                // 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);
 
-                Vector256<float> equalMask = Vector256.Equals(max, current);
-                if (equalMask.AsInt32() != Vector256<int>.Zero)
-                {
-                    Vector256<float> negativeMask = IsNegative(current);
-                    Vector256<int> lessThanMask = Vector256.LessThan(maxIndex, curIndex);
+                // 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);
 
-                    greaterThanMask |= (negativeMask & equalMask) | (~IsNegative(max) & equalMask & lessThanMask.AsSingle());
-                }
+                // 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);
 
-                max = ElementWiseSelect(greaterThanMask, max, current);
+                // 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);
 
-                maxIndex = ElementWiseSelect(greaterThanMask.AsInt32(), maxIndex, curIndex);
+                // Return 0
+                return resultIndex.As<T, byte>().ToScalar();
             }
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector512<float> result, Vector512<int> resultIndex)
-            {
-                // Min the upper/lower halves of the Vector512
-                Vector256<float> resultLower = result.GetLower();
-                Vector256<int> indexLower = resultIndex.GetLower();
+            throw new NotSupportedException();
+        }
 
-                Invoke(ref resultLower, result.GetUpper(), ref indexLower, resultIndex.GetUpper());
-                return Invoke(resultLower, indexLower);
-            }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int IndexOfFinalAggregate<T, TIndexOfOperator>(Vector256<T> result, Vector256<T> resultIndex)
+            where T : INumber<T>
+            where TIndexOfOperator : struct, IIndexOfOperator<T>
+        {
+            // Min the upper/lower halves of the Vector256
+            Vector128<T> resultLower = result.GetLower();
+            Vector128<T> indexLower = resultIndex.GetLower();
 
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector512<float> max, Vector512<float> current, ref Vector512<int> maxIndex, Vector512<int> curIndex)
-            {
-                Vector512<float> greaterThanMask = Vector512.GreaterThan(max, current);
+            TIndexOfOperator.Invoke(ref resultLower, result.GetUpper(), ref indexLower, resultIndex.GetUpper());
+            return IndexOfFinalAggregate<T, TIndexOfOperator>(resultLower, indexLower);
+        }
 
-                Vector512<float> equalMask = Vector512.Equals(max, current);
-                if (equalMask.AsInt32() != Vector512<int>.Zero)
-                {
-                    Vector512<float> negativeMask = IsNegative(current);
-                    Vector512<int> lessThanMask = Vector512.LessThan(maxIndex, curIndex);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int IndexOfFinalAggregate<T, TIndexOfOperator>(Vector512<T> result, Vector512<T> resultIndex)
+            where T : INumber<T>
+            where TIndexOfOperator : struct, IIndexOfOperator<T>
+        {
+            Vector256<T> resultLower = result.GetLower();
+            Vector256<T> indexLower = resultIndex.GetLower();
 
-                    greaterThanMask |= (negativeMask & equalMask) | (~IsNegative(max) & equalMask & lessThanMask.AsSingle());
-                }
+            TIndexOfOperator.Invoke(ref resultLower, result.GetUpper(), ref indexLower, resultIndex.GetUpper());
+            return IndexOfFinalAggregate<T, TIndexOfOperator>(resultLower, indexLower);
+        }
 
-                max = ElementWiseSelect(greaterThanMask, max, current);
+        [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>();
 
-                maxIndex = ElementWiseSelect(greaterThanMask.AsInt32(), maxIndex, curIndex);
-            }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static 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 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>Returns the index of MathF.Max(x, y)</summary>
+        internal readonly struct IndexOfMaxOperator<T> : IIndexOfOperator<T> where T : INumber<T>
+        {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(ref float result, float current, int resultIndex, int curIndex)
+            public static void Invoke(ref Vector128<T> result, Vector128<T> current, ref Vector128<T> resultIndex, Vector128<T> currentIndex)
             {
-                if (result == current)
+                Vector128<T> useResult = Vector128.GreaterThan(result, current);
+                Vector128<T> equalMask = Vector128.Equals(result, current);
+
+                if (equalMask != Vector128<T>.Zero)
                 {
-                    if (IsNegative(result) && !IsNegative(current))
+                    Vector128<T> lessThanIndexMask = IndexLessThan(resultIndex, currentIndex);
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        result = current;
-                        return curIndex;
+                        // 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;
                     }
-                }
-                else if (current > result)
-                {
-                    result = current;
-                    return curIndex;
                 }
 
-                return resultIndex;
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
-        }
 
-        internal readonly struct IndexOfMaxMagnitudeOperator : IIndexOfOperator
-        {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector128<float> result, Vector128<int> maxIndex)
+            public static void Invoke(ref Vector256<T> result, Vector256<T> current, ref Vector256<T> resultIndex, Vector256<T> currentIndex)
             {
-                Vector128<float> tmpResult = Vector128.Shuffle(result, Vector128.Create(2, 3, 0, 1));
-                Vector128<int> tmpIndex = Vector128.Shuffle(maxIndex, Vector128.Create(2, 3, 0, 1));
+                Vector256<T> useResult = Vector256.GreaterThan(result, current);
+                Vector256<T> equalMask = Vector256.Equals(result, current);
 
-                Invoke(ref result, tmpResult, ref maxIndex, tmpIndex);
-
-                tmpResult = Vector128.Shuffle(result, Vector128.Create(1, 0, 3, 2));
-                tmpIndex = Vector128.Shuffle(maxIndex, Vector128.Create(1, 0, 3, 2));
+                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;
+                    }
+                }
 
-                Invoke(ref result, tmpResult, ref maxIndex, tmpIndex);
-                return maxIndex.ToScalar();
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector128<float> max, Vector128<float> current, ref Vector128<int> maxIndex, Vector128<int> curIndex)
+            public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex)
             {
-                Vector128<float> maxMag = Vector128.Abs(max), currentMag = Vector128.Abs(current);
-
-                Vector128<float> greaterThanMask = Vector128.GreaterThan(maxMag, currentMag);
+                Vector512<T> useResult = Vector512.GreaterThan(result, current);
+                Vector512<T> equalMask = Vector512.Equals(result, current);
 
-                Vector128<float> equalMask = Vector128.Equals(max, current);
-                if (equalMask.AsInt32() != Vector128<int>.Zero)
+                if (equalMask != Vector512<T>.Zero)
                 {
-                    Vector128<float> negativeMask = IsNegative(current);
-                    Vector128<int> lessThanMask = Vector128.LessThan(maxIndex, curIndex);
-
-                    greaterThanMask |= (negativeMask & equalMask) | (~IsNegative(max) & equalMask & lessThanMask.AsSingle());
+                    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;
+                    }
                 }
 
-                max = ElementWiseSelect(greaterThanMask, max, current);
-
-                maxIndex = ElementWiseSelect(greaterThanMask.AsInt32(), maxIndex, curIndex);
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector256<float> result, Vector256<int> maxIndex)
+            public static int Invoke(ref T result, T current, int resultIndex, int currentIndex)
             {
-                // Max the upper/lower halves of the Vector256
-                Vector128<float> resultLower = result.GetLower();
-                Vector128<int> indexLower = maxIndex.GetLower();
+                if (result == current)
+                {
+                    bool resultNegative = IsNegative(result);
+                    if ((resultNegative == IsNegative(current)) ? (currentIndex < resultIndex) : resultNegative)
+                    {
+                        result = current;
+                        return currentIndex;
+                    }
+                }
+                else if (current > result)
+                {
+                    result = current;
+                    return currentIndex;
+                }
 
-                Invoke(ref resultLower, result.GetUpper(), ref indexLower, maxIndex.GetUpper());
-                return Invoke(resultLower, indexLower);
+                return resultIndex;
             }
+        }
 
+        internal readonly struct IndexOfMaxMagnitudeOperator<T> : IIndexOfOperator<T> where T : INumber<T>
+        {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector256<float> max, Vector256<float> current, ref Vector256<int> maxIndex, Vector256<int> curIndex)
+            public static void Invoke(ref Vector128<T> result, Vector128<T> current, ref Vector128<T> resultIndex, Vector128<T> currentIndex)
             {
-                Vector256<float> maxMag = Vector256.Abs(max), currentMag = Vector256.Abs(current);
-
-                Vector256<float> greaterThanMask = Vector256.GreaterThan(maxMag, currentMag);
+                Vector128<T> resultMag = Vector128.Abs(result), currentMag = Vector128.Abs(current);
+                Vector128<T> useResult = Vector128.GreaterThan(resultMag, currentMag);
+                Vector128<T> equalMask = Vector128.Equals(resultMag, currentMag);
 
-                Vector256<float> equalMask = Vector256.Equals(max, current);
-                if (equalMask.AsInt32() != Vector256<int>.Zero)
+                if (equalMask != Vector128<T>.Zero)
                 {
-                    Vector256<float> negativeMask = IsNegative(current);
-                    Vector256<int> lessThanMask = Vector256.LessThan(maxIndex, curIndex);
-
-                    greaterThanMask |= (negativeMask & equalMask) | (~IsNegative(max) & equalMask & lessThanMask.AsSingle());
+                    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;
+                    }
                 }
 
-                max = ElementWiseSelect(greaterThanMask, max, current);
-
-                maxIndex = ElementWiseSelect(greaterThanMask.AsInt32(), maxIndex, curIndex);
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector512<float> result, Vector512<int> resultIndex)
+            public static void Invoke(ref Vector256<T> result, Vector256<T> current, ref Vector256<T> resultIndex, Vector256<T> currentIndex)
             {
-                // Min the upper/lower halves of the Vector512
-                Vector256<float> resultLower = result.GetLower();
-                Vector256<int> indexLower = resultIndex.GetLower();
+                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)
+                {
+                    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;
+                    }
+                }
 
-                Invoke(ref resultLower, result.GetUpper(), ref indexLower, resultIndex.GetUpper());
-                return Invoke(resultLower, indexLower);
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector512<float> max, Vector512<float> current, ref Vector512<int> maxIndex, Vector512<int> curIndex)
+            public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex)
             {
-                Vector512<float> maxMag = Vector512.Abs(max), currentMag = Vector512.Abs(current);
-                Vector512<float> greaterThanMask = Vector512.GreaterThan(maxMag, currentMag);
+                Vector512<T> resultMag = Vector512.Abs(result), currentMag = Vector512.Abs(current);
+                Vector512<T> useResult = Vector512.GreaterThan(resultMag, currentMag);
+                Vector512<T> equalMask = Vector512.Equals(resultMag, currentMag);
 
-                Vector512<float> equalMask = Vector512.Equals(max, current);
-                if (equalMask.AsInt32() != Vector512<int>.Zero)
+                if (equalMask != Vector512<T>.Zero)
                 {
-                    Vector512<float> negativeMask = IsNegative(current);
-                    Vector512<int> lessThanMask = Vector512.LessThan(maxIndex, curIndex);
-
-                    greaterThanMask |= (negativeMask & equalMask) | (~IsNegative(max) & equalMask & lessThanMask.AsSingle());
+                    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;
+                    }
                 }
 
-                max = ElementWiseSelect(greaterThanMask, max, current);
-
-                maxIndex = ElementWiseSelect(greaterThanMask.AsInt32(), maxIndex, curIndex);
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(ref float result, float current, int resultIndex, int curIndex)
+            public static int Invoke(ref T result, T current, int resultIndex, int currentIndex)
             {
-                float curMaxAbs = MathF.Abs(result);
-                float currentAbs = MathF.Abs(current);
+                T resultMag = T.Abs(result);
+                T currentMag = T.Abs(current);
 
-                if (curMaxAbs == currentAbs)
+                if (resultMag == currentMag)
                 {
-                    if (IsNegative(result) && !IsNegative(current))
+                    bool resultNegative = IsNegative(result);
+                    if ((resultNegative == IsNegative(current)) ? (currentIndex < resultIndex) : resultNegative)
                     {
                         result = current;
-                        return curIndex;
+                        return currentIndex;
                     }
                 }
-                else if (currentAbs > curMaxAbs)
+                else if (currentMag > resultMag)
                 {
                     result = current;
-                    return curIndex;
+                    return currentIndex;
                 }
 
                 return resultIndex;
@@ -10099,243 +10461,210 @@ public static int Invoke(ref float result, float current, int resultIndex, int c
         }
 
         /// <summary>Returns the index of MathF.Min(x, y)</summary>
-        internal readonly struct IndexOfMinOperator : IIndexOfOperator
+        internal readonly struct IndexOfMinOperator<T> : IIndexOfOperator<T> where T : INumber<T>
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector128<float> result, Vector128<int> resultIndex)
-            {
-                Vector128<float> tmpResult = Vector128.Shuffle(result, Vector128.Create(2, 3, 0, 1));
-                Vector128<int> tmpIndex = Vector128.Shuffle(resultIndex, Vector128.Create(2, 3, 0, 1));
-
-                Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
-
-                tmpResult = Vector128.Shuffle(result, Vector128.Create(1, 0, 3, 2));
-                tmpIndex = Vector128.Shuffle(resultIndex, Vector128.Create(1, 0, 3, 2));
-
-                Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
-                return resultIndex.ToScalar();
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector128<float> result, Vector128<float> current, ref Vector128<int> resultIndex, Vector128<int> curIndex)
+            public static void Invoke(ref Vector128<T> result, Vector128<T> current, ref Vector128<T> resultIndex, Vector128<T> currentIndex)
             {
-                Vector128<float> lessThanMask = Vector128.LessThan(result, current);
+                Vector128<T> useResult = Vector128.LessThan(result, current);
+                Vector128<T> equalMask = Vector128.Equals(result, current);
 
-                Vector128<float> equalMask = Vector128.Equals(result, current);
-                if (equalMask.AsInt32() != Vector128<int>.Zero)
+                if (equalMask != Vector128<T>.Zero)
                 {
-                    Vector128<float> negativeMask = IsNegative(current);
-                    Vector128<int> lessThanIndexMask = Vector128.LessThan(resultIndex, curIndex);
-
-                    lessThanMask |= (~negativeMask & equalMask) | (IsNegative(result) & equalMask & lessThanIndexMask.AsSingle());
+                    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;
+                    }
                 }
 
-                result = ElementWiseSelect(lessThanMask, result, current);
-
-                resultIndex = ElementWiseSelect(lessThanMask.AsInt32(), resultIndex, curIndex);
-            }
-
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector256<float> result, Vector256<int> resultIndex)
-            {
-                // Min the upper/lower halves of the Vector256
-                Vector128<float> resultLower = result.GetLower();
-                Vector128<int> indexLower = resultIndex.GetLower();
-
-                Invoke(ref resultLower, result.GetUpper(), ref indexLower, resultIndex.GetUpper());
-                return Invoke(resultLower, indexLower);
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector256<float> result, Vector256<float> current, ref Vector256<int> resultIndex, Vector256<int> curIndex)
+            public static void Invoke(ref Vector256<T> result, Vector256<T> current, ref Vector256<T> resultIndex, Vector256<T> currentIndex)
             {
-                Vector256<float> lessThanMask = Vector256.LessThan(result, current);
+                Vector256<T> useResult = Vector256.LessThan(result, current);
+                Vector256<T> equalMask = Vector256.Equals(result, current);
 
-                Vector256<float> equalMask = Vector256.Equals(result, current);
-                if (equalMask.AsInt32() != Vector256<int>.Zero)
+                if (equalMask != Vector256<T>.Zero)
                 {
-                    Vector256<float> negativeMask = IsNegative(current);
-                    Vector256<int> lessThanIndexMask = Vector256.LessThan(resultIndex, curIndex);
-
-                    lessThanMask |= (~negativeMask & equalMask) | (IsNegative(result) & equalMask & lessThanIndexMask.AsSingle());
+                    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;
+                    }
                 }
 
-                result = ElementWiseSelect(lessThanMask, result, current);
-
-                resultIndex = ElementWiseSelect(lessThanMask.AsInt32(), resultIndex, curIndex);
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector512<float> result, Vector512<int> resultIndex)
+            public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex)
             {
-                // Min the upper/lower halves of the Vector512
-                Vector256<float> resultLower = result.GetLower();
-                Vector256<int> indexLower = resultIndex.GetLower();
+                Vector512<T> useResult = Vector512.LessThan(result, current);
+                Vector512<T> equalMask = Vector512.Equals(result, current);
 
-                Invoke(ref resultLower, result.GetUpper(), ref indexLower, resultIndex.GetUpper());
-                return Invoke(resultLower, indexLower);
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector512<float> result, Vector512<float> current, ref Vector512<int> resultIndex, Vector512<int> curIndex)
-            {
-                Vector512<float> lessThanMask = Vector512.LessThan(result, current);
-
-                Vector512<float> equalMask = Vector512.Equals(result, current);
-                if (equalMask.AsInt32() != Vector512<int>.Zero)
+                if (equalMask != Vector512<T>.Zero)
                 {
-                    Vector512<float> negativeMask = IsNegative(current);
-                    Vector512<int> lessThanIndexMask = Vector512.LessThan(resultIndex, curIndex);
-
-                    lessThanMask |= (~negativeMask & equalMask) | (IsNegative(result) & equalMask & lessThanIndexMask.AsSingle());
+                    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;
+                    }
                 }
 
-                result = ElementWiseSelect(lessThanMask, result, current);
-
-                resultIndex = ElementWiseSelect(lessThanMask.AsInt32(), resultIndex, curIndex);
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(ref float result, float current, int resultIndex, int curIndex)
+            public static int Invoke(ref T result, T current, int resultIndex, int currentIndex)
             {
                 if (result == current)
                 {
-                    if (IsPositive(result) && !IsPositive(current))
+                    bool currentNegative = IsNegative(current);
+                    if ((IsNegative(result) == currentNegative) ? (currentIndex < resultIndex) : currentNegative)
                     {
                         result = current;
-                        return curIndex;
+                        return currentIndex;
                     }
                 }
                 else if (current < result)
                 {
                     result = current;
-                    return curIndex;
+                    return currentIndex;
                 }
 
                 return resultIndex;
             }
         }
 
-        internal readonly struct IndexOfMinMagnitudeOperator : IIndexOfOperator
+        internal readonly struct IndexOfMinMagnitudeOperator<T> : IIndexOfOperator<T> where T : INumber<T>
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector128<float> result, Vector128<int> resultIndex)
+            public static void Invoke(ref Vector128<T> result, Vector128<T> current, ref Vector128<T> resultIndex, Vector128<T> currentIndex)
             {
-                Vector128<float> tmpResult = Vector128.Shuffle(result, Vector128.Create(2, 3, 0, 1));
-                Vector128<int> tmpIndex = Vector128.Shuffle(resultIndex, Vector128.Create(2, 3, 0, 1));
-
-                Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
+                Vector128<T> resultMag = Vector128.Abs(result), currentMag = Vector128.Abs(current);
+                Vector128<T> useResult = Vector128.LessThan(resultMag, currentMag);
+                Vector128<T> equalMask = Vector128.Equals(resultMag, currentMag);
 
-                tmpResult = Vector128.Shuffle(result, Vector128.Create(1, 0, 3, 2));
-                tmpIndex = Vector128.Shuffle(resultIndex, Vector128.Create(1, 0, 3, 2));
-
-                Invoke(ref result, tmpResult, ref resultIndex, tmpIndex);
-                return resultIndex.ToScalar();
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector128<float> result, Vector128<float> current, ref Vector128<int> resultIndex, Vector128<int> curIndex)
-            {
-                Vector128<float> minMag = Vector128.Abs(result), currentMag = Vector128.Abs(current);
-
-                Vector128<float> lessThanMask = Vector128.LessThan(minMag, currentMag);
-
-                Vector128<float> equalMask = Vector128.Equals(result, current);
-                if (equalMask.AsInt32() != Vector128<int>.Zero)
+                if (equalMask != Vector128<T>.Zero)
                 {
-                    Vector128<float> negativeMask = IsNegative(current);
-                    Vector128<int> lessThanIndexMask = Vector128.LessThan(resultIndex, curIndex);
-
-                    lessThanMask |= (~negativeMask & equalMask) | (IsNegative(result) & equalMask & lessThanIndexMask.AsSingle());
+                    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;
+                    }
                 }
 
-                result = ElementWiseSelect(lessThanMask, result, current);
-
-                resultIndex = ElementWiseSelect(lessThanMask.AsInt32(), resultIndex, curIndex);
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector256<float> result, Vector256<int> resultIndex)
+            public static void Invoke(ref Vector256<T> result, Vector256<T> current, ref Vector256<T> resultIndex, Vector256<T> currentIndex)
             {
-                // Min the upper/lower halves of the Vector256
-                Vector128<float> resultLower = result.GetLower();
-                Vector128<int> indexLower = resultIndex.GetLower();
+                Vector256<T> resultMag = Vector256.Abs(result), currentMag = Vector256.Abs(current);
+                Vector256<T> useResult = Vector256.LessThan(resultMag, currentMag);
+                Vector256<T> equalMask = Vector256.Equals(resultMag, currentMag);
 
-                Invoke(ref resultLower, result.GetUpper(), ref indexLower, resultIndex.GetUpper());
-                return Invoke(resultLower, indexLower);
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector256<float> result, Vector256<float> current, ref Vector256<int> resultIndex, Vector256<int> curIndex)
-            {
-                Vector256<float> minMag = Vector256.Abs(result), currentMag = Vector256.Abs(current);
-
-                Vector256<float> lessThanMask = Vector256.LessThan(minMag, currentMag);
-
-                Vector256<float> equalMask = Vector256.Equals(result, current);
-                if (equalMask.AsInt32() != Vector256<int>.Zero)
+                if (equalMask != Vector256<T>.Zero)
                 {
-                    Vector256<float> negativeMask = IsNegative(current);
-                    Vector256<int> lessThanIndexMask = Vector256.LessThan(resultIndex, curIndex);
-
-                    lessThanMask |= (~negativeMask & equalMask) | (IsNegative(result) & equalMask & lessThanIndexMask.AsSingle());
+                    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;
+                    }
                 }
 
-                result = ElementWiseSelect(lessThanMask, result, current);
-
-                resultIndex = ElementWiseSelect(lessThanMask.AsInt32(), resultIndex, curIndex);
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(Vector512<float> result, Vector512<int> resultIndex)
-            {
-                // Min the upper/lower halves of the Vector512
-                Vector256<float> resultLower = result.GetLower();
-                Vector256<int> indexLower = resultIndex.GetLower();
-
-                Invoke(ref resultLower, result.GetUpper(), ref indexLower, resultIndex.GetUpper());
-                return Invoke(resultLower, indexLower);
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static void Invoke(ref Vector512<float> result, Vector512<float> current, ref Vector512<int> resultIndex, Vector512<int> curIndex)
+            public static void Invoke(ref Vector512<T> result, Vector512<T> current, ref Vector512<T> resultIndex, Vector512<T> currentIndex)
             {
-                Vector512<float> minMag = Vector512.Abs(result), currentMag = Vector512.Abs(current);
+                Vector512<T> resultMag = Vector512.Abs(result), currentMag = Vector512.Abs(current);
+                Vector512<T> useResult = Vector512.LessThan(resultMag, currentMag);
+                Vector512<T> equalMask = Vector512.Equals(resultMag, currentMag);
 
-                Vector512<float> lessThanMask = Vector512.LessThan(minMag, currentMag);
-
-                Vector512<float> equalMask = Vector512.Equals(result, current);
-                if (equalMask.AsInt32() != Vector512<int>.Zero)
+                if (equalMask != Vector512<T>.Zero)
                 {
-                    Vector512<float> negativeMask = IsNegative(current);
-                    Vector512<int> lessThanIndexMask = Vector512.LessThan(resultIndex, curIndex);
-
-                    lessThanMask |= (~negativeMask & equalMask) | (IsNegative(result) & equalMask & lessThanIndexMask.AsSingle());
+                    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;
+                    }
                 }
 
-                result = ElementWiseSelect(lessThanMask, result, current);
-
-                resultIndex = ElementWiseSelect(lessThanMask.AsInt32(), resultIndex, curIndex);
+                result = ElementWiseSelect(useResult, result, current);
+                resultIndex = ElementWiseSelect(useResult, resultIndex, currentIndex);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static int Invoke(ref float result, float current, int resultIndex, int curIndex)
+            public static int Invoke(ref T result, T current, int resultIndex, int currentIndex)
             {
-                float curMinAbs = MathF.Abs(result);
-                float currentAbs = MathF.Abs(current);
-                if (curMinAbs == currentAbs)
+                T resultMag = T.Abs(result);
+                T currentMag = T.Abs(current);
+
+                if (resultMag == currentMag)
                 {
-                    if (IsPositive(result) && !IsPositive(current))
+                    bool currentNegative = IsNegative(current);
+                    if ((IsNegative(result) == currentNegative) ? (currentIndex < resultIndex) : currentNegative)
                     {
                         result = current;
-                        return curIndex;
+                        return currentIndex;
                     }
                 }
-                else if (currentAbs < curMinAbs)
+                else if (currentMag < resultMag)
                 {
                     result = current;
-                    return curIndex;
+                    return currentIndex;
                 }
 
                 return resultIndex;
@@ -10346,6 +10675,8 @@ public static int Invoke(ref float result, float current, int resultIndex, int c
         internal readonly struct MaxPropagateNaNOperator<T> : IBinaryOperator<T>
              where T : INumber<T>
         {
+            public static bool Vectorizable => true;
+
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static T Invoke(T x, T y) => T.Max(x, y);
 
@@ -10419,6 +10750,8 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         internal readonly struct MaxMagnitudeOperator<T> : IAggregationOperator<T>
             where T : INumberBase<T>
         {
+            public static bool Vectorizable => true;
+
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static T Invoke(T x, T y) => T.MaxMagnitude(x, y);
 
@@ -10506,6 +10839,8 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         internal readonly struct MaxMagnitudePropagateNaNOperator<T> : IBinaryOperator<T>
             where T : INumberBase<T>
         {
+            public static bool Vectorizable => true;
+
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static T Invoke(T x, T y) => T.MaxMagnitude(x, y);
 
@@ -10574,6 +10909,8 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         internal readonly struct MinOperator<T> : IAggregationOperator<T>
             where T : INumber<T>
         {
+            public static bool Vectorizable => true;
+
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static T Invoke(T x, T y)
             {
@@ -10647,6 +10984,8 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         internal readonly struct MinPropagateNaNOperator<T> : IBinaryOperator<T>
             where T : INumber<T>
         {
+            public static bool Vectorizable => true;
+
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static T Invoke(T x, T y) => T.Min(x, y);
 
@@ -10720,6 +11059,8 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         internal readonly struct MinMagnitudeOperator<T> : IAggregationOperator<T>
             where T : INumberBase<T>
         {
+            public static bool Vectorizable => true;
+
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static T Invoke(T x, T y) => T.MinMagnitude(x, y);
 
@@ -10804,6 +11145,8 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         internal readonly struct MinMagnitudePropagateNaNOperator<T> : IBinaryOperator<T>
             where T : INumberBase<T>
         {
+            public static bool Vectorizable => true;
+
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static T Invoke(T x, T y) => T.MinMagnitude(x, y);
 
@@ -10896,6 +11239,24 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
             public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z) => (x * y) + z;
         }
 
+        /// <summary>(x * y) + z</summary>
+        internal readonly struct FusedMultiplyAddOperator<T> : ITernaryOperator<T> where T : IFloatingPointIeee754<T>
+        {
+            public static T Invoke(T x, T y, T z) => FusedMultiplyAdd(x, y, z);
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y, Vector128<T> z) => FusedMultiplyAdd(x, y, z);
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> z) => FusedMultiplyAdd(x, y, z);
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z) => FusedMultiplyAdd(x, y, z);
+        }
+
+        /// <summary>(x * (1 - z)) + (y * z)</summary>
+        internal readonly struct LerpOperator<T> : ITernaryOperator<T> where T : IFloatingPointIeee754<T>
+        {
+            public static T Invoke(T x, T y, T amount) => T.Lerp(x, y, amount);
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y, Vector128<T> amount) => (x * (Vector128<T>.One - amount)) + (y * amount);
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> amount) => (x * (Vector256<T>.One - amount)) + (y * amount);
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> amount) => (x * (Vector512<T>.One - amount)) + (y * amount);
+        }
+
         /// <summary>x</summary>
         internal readonly struct IdentityOperator<T> : IUnaryOperator<T>
         {
@@ -11582,6 +11943,253 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 #endif
 
+        /// <summary>T.ExpM1(x)</summary>
+        internal readonly struct ExpM1Operator<T> : IUnaryOperator<T>
+            where T : IExponentialFunctions<T>
+        {
+            public static bool Vectorizable => ExpOperator<T>.Vectorizable;
+
+            public static T Invoke(T x) => T.ExpM1(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => ExpOperator<T>.Invoke(x) - Vector128<T>.One;
+            public static Vector256<T> Invoke(Vector256<T> x) => ExpOperator<T>.Invoke(x) - Vector256<T>.One;
+            public static Vector512<T> Invoke(Vector512<T> x) => ExpOperator<T>.Invoke(x) - Vector512<T>.One;
+        }
+
+        /// <summary>T.Exp2(x)</summary>
+        internal readonly struct Exp2Operator<T> : IUnaryOperator<T>
+            where T : IExponentialFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+
+            public static T Invoke(T x) => T.Exp2(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.Exp2M1(x)</summary>
+        internal readonly struct Exp2M1Operator<T> : IUnaryOperator<T>
+            where T : IExponentialFunctions<T>
+        {
+            public static bool Vectorizable => Exp2Operator<T>.Vectorizable;
+
+            public static T Invoke(T x) => T.Exp2M1(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => Exp2Operator<T>.Invoke(x) - Vector128<T>.One;
+            public static Vector256<T> Invoke(Vector256<T> x) => Exp2Operator<T>.Invoke(x) - Vector256<T>.One;
+            public static Vector512<T> Invoke(Vector512<T> x) => Exp2Operator<T>.Invoke(x) - Vector512<T>.One;
+        }
+
+        /// <summary>T.Exp10(x)</summary>
+        internal readonly struct Exp10Operator<T> : IUnaryOperator<T>
+            where T : IExponentialFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+
+            public static T Invoke(T x) => T.Exp10(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.Exp10M1(x)</summary>
+        internal readonly struct Exp10M1Operator<T> : IUnaryOperator<T>
+            where T : IExponentialFunctions<T>
+        {
+            public static bool Vectorizable => Exp2Operator<T>.Vectorizable;
+
+            public static T Invoke(T x) => T.Exp10M1(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => Exp10Operator<T>.Invoke(x) - Vector128<T>.One;
+            public static Vector256<T> Invoke(Vector256<T> x) => Exp10Operator<T>.Invoke(x) - Vector256<T>.One;
+            public static Vector512<T> Invoke(Vector512<T> x) => Exp10Operator<T>.Invoke(x) - Vector512<T>.One;
+        }
+
+        /// <summary>T.Pow(x, y)</summary>
+        internal readonly struct PowOperator<T> : IBinaryOperator<T>
+            where T : IPowerFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x, T y) => T.Pow(x, y);
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.Sqrt(x)</summary>
+        internal readonly struct SqrtOperator<T> : IUnaryOperator<T>
+            where T : IRootFunctions<T>
+        {
+            public static bool Vectorizable => true;
+            public static T Invoke(T x) => T.Sqrt(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => Vector128.Sqrt(x);
+            public static Vector256<T> Invoke(Vector256<T> x) => Vector256.Sqrt(x);
+            public static Vector512<T> Invoke(Vector512<T> x) => Vector512.Sqrt(x);
+        }
+
+        /// <summary>T.Cbrt(x)</summary>
+        internal readonly struct CbrtOperator<T> : IUnaryOperator<T>
+            where T : IRootFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.Cbrt(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.Hypot(x, y)</summary>
+        internal readonly struct HypotOperator<T> : IBinaryOperator<T>
+            where T : IRootFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x, T y) => T.Hypot(x, y);
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.Acos(x)</summary>
+        internal readonly struct AcosOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.Acos(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.Acosh(x)</summary>
+        internal readonly struct AcoshOperator<T> : IUnaryOperator<T>
+            where T : IHyperbolicFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.Acosh(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.AcosPi(x)</summary>
+        internal readonly struct AcosPiOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => AcosOperator<T>.Vectorizable;
+            public static T Invoke(T x) => T.AcosPi(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => AcosOperator<T>.Invoke(x) / Vector128.Create(T.Pi);
+            public static Vector256<T> Invoke(Vector256<T> x) => AcosOperator<T>.Invoke(x) / Vector256.Create(T.Pi);
+            public static Vector512<T> Invoke(Vector512<T> x) => AcosOperator<T>.Invoke(x) / Vector512.Create(T.Pi);
+        }
+
+        /// <summary>T.Asin(x)</summary>
+        internal readonly struct AsinOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.Asin(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.Asinh(x)</summary>
+        internal readonly struct AsinhOperator<T> : IUnaryOperator<T>
+            where T : IHyperbolicFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.Asinh(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.AsinPi(x)</summary>
+        internal readonly struct AsinPiOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => AsinOperator<T>.Vectorizable;
+            public static T Invoke(T x) => T.AsinPi(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => AsinOperator<T>.Invoke(x) / Vector128.Create(T.Pi);
+            public static Vector256<T> Invoke(Vector256<T> x) => AsinOperator<T>.Invoke(x) / Vector256.Create(T.Pi);
+            public static Vector512<T> Invoke(Vector512<T> x) => AsinOperator<T>.Invoke(x) / Vector512.Create(T.Pi);
+        }
+
+        /// <summary>T.Atan(x)</summary>
+        internal readonly struct AtanOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.Atan(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.Atanh(x)</summary>
+        internal readonly struct AtanhOperator<T> : IUnaryOperator<T>
+            where T : IHyperbolicFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.Atanh(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.AtanPi(x)</summary>
+        internal readonly struct AtanPiOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => AtanOperator<T>.Vectorizable;
+            public static T Invoke(T x) => T.AtanPi(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => AtanOperator<T>.Invoke(x) / Vector128.Create(T.Pi);
+            public static Vector256<T> Invoke(Vector256<T> x) => AtanOperator<T>.Invoke(x) / Vector256.Create(T.Pi);
+            public static Vector512<T> Invoke(Vector512<T> x) => AtanOperator<T>.Invoke(x) / Vector512.Create(T.Pi);
+        }
+
+        /// <summary>T.Atan2(y, x)</summary>
+        internal readonly struct Atan2Operator<T> : IBinaryOperator<T>
+            where T : IFloatingPointIeee754<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T y, T x) => T.Atan2(y, x);
+            public static Vector128<T> Invoke(Vector128<T> y, Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> y, Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> y, Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.Atan2Pi(y, x)</summary>
+        internal readonly struct Atan2PiOperator<T> : IBinaryOperator<T>
+            where T : IFloatingPointIeee754<T>
+        {
+            public static bool Vectorizable => Atan2Operator<T>.Vectorizable;
+            public static T Invoke(T y, T x) => T.Atan2Pi(y, x);
+            public static Vector128<T> Invoke(Vector128<T> y, Vector128<T> x) => Atan2Operator<T>.Invoke(y, x) / Vector128.Create(T.Pi);
+            public static Vector256<T> Invoke(Vector256<T> y, Vector256<T> x) => Atan2Operator<T>.Invoke(y, x) / Vector256.Create(T.Pi);
+            public static Vector512<T> Invoke(Vector512<T> y, Vector512<T> x) => Atan2Operator<T>.Invoke(y, x) / Vector512.Create(T.Pi);
+        }
+
+        /// <summary>T.Cos(x)</summary>
+        internal readonly struct CosOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.Cos(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.CosPi(x)</summary>
+        internal readonly struct CosPiOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => CosOperator<T>.Vectorizable;
+            public static T Invoke(T x) => T.CosPi(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => CosOperator<T>.Invoke(x * Vector128.Create(T.Pi));
+            public static Vector256<T> Invoke(Vector256<T> x) => CosOperator<T>.Invoke(x * Vector256.Create(T.Pi));
+            public static Vector512<T> Invoke(Vector512<T> x) => CosOperator<T>.Invoke(x * Vector512.Create(T.Pi));
+        }
+
         /// <summary>T.Cosh(x)</summary>
         internal readonly struct CoshOperator<T> : IUnaryOperator<T>
             where T : IHyperbolicFunctions<T>
@@ -11646,6 +12254,28 @@ public static Vector512<T> Invoke(Vector512<T> t)
             }
         }
 
+        /// <summary>T.Sin(x)</summary>
+        internal readonly struct SinOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.Sin(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.SinPi(x)</summary>
+        internal readonly struct SinPiOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => SinOperator<T>.Vectorizable;
+            public static T Invoke(T x) => T.SinPi(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => SinOperator<T>.Invoke(x * Vector128.Create(T.Pi));
+            public static Vector256<T> Invoke(Vector256<T> x) => SinOperator<T>.Invoke(x * Vector256.Create(T.Pi));
+            public static Vector512<T> Invoke(Vector512<T> x) => SinOperator<T>.Invoke(x * Vector512.Create(T.Pi));
+        }
+
         /// <summary>T.Sinh(x)</summary>
         internal readonly struct SinhOperator<T> : IUnaryOperator<T>
             where T : IHyperbolicFunctions<T>
@@ -11699,6 +12329,28 @@ public static Vector512<T> Invoke(Vector512<T> t)
             }
         }
 
+        /// <summary>T.Tan(x)</summary>
+        internal readonly struct TanOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.Tan(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.TanPi(x)</summary>
+        internal readonly struct TanPiOperator<T> : IUnaryOperator<T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => TanOperator<T>.Vectorizable;
+            public static T Invoke(T x) => T.TanPi(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => TanOperator<T>.Invoke(x * Vector128.Create(T.Pi));
+            public static Vector256<T> Invoke(Vector256<T> x) => TanOperator<T>.Invoke(x * Vector256.Create(T.Pi));
+            public static Vector512<T> Invoke(Vector512<T> x) => TanOperator<T>.Invoke(x * Vector512.Create(T.Pi));
+        }
+
         /// <summary>T.Tanh(x)</summary>
         internal readonly struct TanhOperator<T> : IUnaryOperator<T>
             where T : IHyperbolicFunctions<T>
@@ -13113,6 +13765,61 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 #endif
 
+        /// <summary>T.Log10(x)</summary>
+        internal readonly struct Log10Operator<T> : IUnaryOperator<T>
+            where T : ILogarithmicFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.Log10(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.LogP1(x)</summary>
+        internal readonly struct LogP1Operator<T> : IUnaryOperator<T>
+            where T : ILogarithmicFunctions<T>
+        {
+            public static bool Vectorizable => LogOperator<T>.Vectorizable;
+            public static T Invoke(T x) => T.LogP1(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => LogOperator<T>.Invoke(x + Vector128<T>.One);
+            public static Vector256<T> Invoke(Vector256<T> x) => LogOperator<T>.Invoke(x + Vector256<T>.One);
+            public static Vector512<T> Invoke(Vector512<T> x) => LogOperator<T>.Invoke(x + Vector512<T>.One);
+        }
+
+        /// <summary>T.Log2P1(x)</summary>
+        internal readonly struct Log2P1Operator<T> : IUnaryOperator<T>
+            where T : ILogarithmicFunctions<T>
+        {
+            public static bool Vectorizable => Log2Operator<T>.Vectorizable;
+            public static T Invoke(T x) => T.Log2P1(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => Log2Operator<T>.Invoke(x + Vector128<T>.One);
+            public static Vector256<T> Invoke(Vector256<T> x) => Log2Operator<T>.Invoke(x + Vector256<T>.One);
+            public static Vector512<T> Invoke(Vector512<T> x) => Log2Operator<T>.Invoke(x + Vector512<T>.One);
+        }
+
+        /// <summary>T.Log10P1(x)</summary>
+        internal readonly struct Log10P1Operator<T> : IUnaryOperator<T>
+            where T : ILogarithmicFunctions<T>
+        {
+            public static bool Vectorizable => Log10Operator<T>.Vectorizable;
+            public static T Invoke(T x) => T.Log10P1(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => Log10Operator<T>.Invoke(x + Vector128<T>.One);
+            public static Vector256<T> Invoke(Vector256<T> x) => Log10Operator<T>.Invoke(x + Vector256<T>.One);
+            public static Vector512<T> Invoke(Vector512<T> x) => Log10Operator<T>.Invoke(x + Vector512<T>.One);
+        }
+
+        /// <summary>T.Log(x, y)</summary>
+        internal readonly struct LogBaseOperator<T> : IBinaryOperator<T>
+            where T : ILogarithmicFunctions<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x, T y) => T.Log(x, y);
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => throw new NotSupportedException();
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static Vector128<T> ElementWiseSelect<T>(Vector128<T> mask, Vector128<T> left, Vector128<T> right)
         {
@@ -13169,7 +13876,7 @@ private static Vector512<T> ElementWiseSelect<T>(Vector512<T> mask, Vector512<T>
             return Vector512.ConditionalSelect(mask, left, right);
         }
 
-        /// <summary>1f / (1f + MathF.Exp(-x))</summary>
+        /// <summary>1 / (1 + T.Exp(-x))</summary>
         internal readonly struct SigmoidOperator<T> : IUnaryOperator<T> where T : IExponentialFunctions<T>
         {
             public static bool Vectorizable => typeof(T) == typeof(float);
@@ -13179,6 +13886,350 @@ private static Vector512<T> ElementWiseSelect<T>(Vector512<T> mask, Vector512<T>
             public static Vector512<T> Invoke(Vector512<T> x) => Vector512.Create(T.One) / (Vector512.Create(T.One) + ExpOperator<T>.Invoke(-x));
         }
 
+        internal readonly struct CeilingOperator<T> : IUnaryOperator<T> where T : IFloatingPoint<T>
+        {
+            public static bool Vectorizable => typeof(T) == typeof(float) || typeof(T) == typeof(double);
+
+            public static T Invoke(T x) => T.Ceiling(x);
+
+            public static Vector128<T> Invoke(Vector128<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    return Vector128.Ceiling(x.AsSingle()).As<float, T>();
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector128.Ceiling(x.AsDouble()).As<double, T>();
+                }
+
+                throw new NotSupportedException();
+            }
+
+            public static Vector256<T> Invoke(Vector256<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    return Vector256.Ceiling(x.AsSingle()).As<float, T>();
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector256.Ceiling(x.AsDouble()).As<double, T>();
+                }
+
+                throw new NotSupportedException();
+            }
+
+            public static Vector512<T> Invoke(Vector512<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    return Vector512.Ceiling(x.AsSingle()).As<float, T>();
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector512.Ceiling(x.AsDouble()).As<double, T>();
+                }
+
+                throw new NotSupportedException();
+            }
+        }
+
+        internal readonly struct FloorOperator<T> : IUnaryOperator<T> where T : IFloatingPoint<T>
+        {
+            public static bool Vectorizable => typeof(T) == typeof(float) || typeof(T) == typeof(double);
+
+            public static T Invoke(T x) => T.Floor(x);
+
+            public static Vector128<T> Invoke(Vector128<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    return Vector128.Floor(x.AsSingle()).As<float, T>();
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector128.Floor(x.AsDouble()).As<double, T>();
+                }
+
+                throw new NotSupportedException();
+            }
+
+            public static Vector256<T> Invoke(Vector256<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    return Vector256.Floor(x.AsSingle()).As<float, T>();
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector256.Floor(x.AsDouble()).As<double, T>();
+                }
+
+                throw new NotSupportedException();
+            }
+
+            public static Vector512<T> Invoke(Vector512<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    return Vector512.Floor(x.AsSingle()).As<float, T>();
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector512.Floor(x.AsDouble()).As<double, T>();
+                }
+
+                throw new NotSupportedException();
+            }
+        }
+
+        private readonly struct TruncateOperator<T> : IUnaryOperator<T> where T : IFloatingPoint<T>
+        {
+            public static bool Vectorizable => typeof(T) == typeof(float) || typeof(T) == typeof(double);
+
+            public static T Invoke(T x) => T.Truncate(x);
+
+            public static Vector128<T> Invoke(Vector128<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    if (Sse41.IsSupported)
+                    {
+                        return Sse41.RoundToZero(x.AsSingle()).As<float, T>();
+                    }
+
+                    if (AdvSimd.IsSupported)
+                    {
+                        return AdvSimd.RoundToZero(x.AsSingle()).As<float, T>();
+                    }
+
+                    return Vector128.ConditionalSelect(Vector128.GreaterThanOrEqual(x, Vector128<T>.Zero),
+                        Vector128.Floor(x.AsSingle()).As<float, T>(),
+                        Vector128.Ceiling(x.AsSingle()).As<float, T>());
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    if (Sse41.IsSupported)
+                    {
+                        return Sse41.RoundToZero(x.AsDouble()).As<double, T>();
+                    }
+
+                    return Vector128.ConditionalSelect(Vector128.GreaterThanOrEqual(x, Vector128<T>.Zero),
+                        Vector128.Floor(x.AsDouble()).As<double, T>(),
+                        Vector128.Ceiling(x.AsDouble()).As<double, T>());
+                }
+
+                throw new NotSupportedException();
+            }
+
+            public static Vector256<T> Invoke(Vector256<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    if (Avx.IsSupported)
+                    {
+                        return Avx.RoundToZero(x.AsSingle()).As<float, T>();
+                    }
+
+                    return Vector256.ConditionalSelect(Vector256.GreaterThanOrEqual(x, Vector256<T>.Zero),
+                        Vector256.Floor(x.AsSingle()).As<float, T>(),
+                        Vector256.Ceiling(x.AsSingle()).As<float, T>());
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    if (Avx.IsSupported)
+                    {
+                        return Avx.RoundToZero(x.AsDouble()).As<double, T>();
+                    }
+
+                    return Vector256.ConditionalSelect(Vector256.GreaterThanOrEqual(x, Vector256<T>.Zero),
+                        Vector256.Floor(x.AsDouble()).As<double, T>(),
+                        Vector256.Ceiling(x.AsDouble()).As<double, T>());
+                }
+
+                throw new NotSupportedException();
+            }
+
+            public static Vector512<T> Invoke(Vector512<T> x)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    if (Avx512F.IsSupported)
+                    {
+                        return Avx512F.RoundScale(x.AsSingle(), 0b11).As<float, T>();
+                    }
+
+                    return Vector512.ConditionalSelect(Vector512.GreaterThanOrEqual(x, Vector512<T>.Zero),
+                        Vector512.Floor(x.AsSingle()).As<float, T>(),
+                        Vector512.Ceiling(x.AsSingle()).As<float, T>());
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    if (Avx512F.IsSupported)
+                    {
+                        return Avx512F.RoundScale(x.AsDouble(), 0b11).As<double, T>();
+                    }
+
+                    return Vector512.ConditionalSelect(Vector512.GreaterThanOrEqual(x, Vector512<T>.Zero),
+                        Vector512.Floor(x.AsDouble()).As<double, T>(),
+                        Vector512.Ceiling(x.AsDouble()).As<double, T>());
+                }
+
+                throw new NotSupportedException();
+            }
+        }
+
+        /// <summary>T.PopCount(x)</summary>
+        internal readonly struct PopCountOperator<T> : IUnaryOperator<T> where T : IBinaryInteger<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.PopCount(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.LeadingZeroCount(x)</summary>
+        internal readonly struct LeadingZeroCountOperator<T> : IUnaryOperator<T> where T : IBinaryInteger<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.LeadingZeroCount(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        /// <summary>T.TrailingZeroCount(x)</summary>
+        internal readonly struct TrailingZeroCountOperator<T> : IUnaryOperator<T> where T : IBinaryInteger<T>
+        {
+            public static bool Vectorizable => false; // TODO: Vectorize
+            public static T Invoke(T x) => T.TrailingZeroCount(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => throw new NotSupportedException();
+            public static Vector256<T> Invoke(Vector256<T> x) => throw new NotSupportedException();
+            public static Vector512<T> Invoke(Vector512<T> x) => throw new NotSupportedException();
+        }
+
+        private readonly struct CopySignOperator<T> : IBinaryOperator<T> where T : INumber<T>
+        {
+            public static bool Vectorizable => true;
+
+            public static T Invoke(T x, T y) => T.CopySign(x, y);
+
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    return Vector128.ConditionalSelect(Vector128.Create(-0.0f).As<float, T>(), y, x);
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector128.ConditionalSelect(Vector128.Create(-0.0d).As<double, T>(), y, x);
+                }
+
+                if (typeof(T) == typeof(sbyte) || typeof(T) == typeof(short) || typeof(T) == typeof(int) || typeof(T) == typeof(long) || typeof(T) == typeof(nint))
+                {
+                    Vector128<T> absValue = Vector128.Abs(x);
+                    Vector128<T> sign = Vector128.GreaterThanOrEqual(y, Vector128<T>.Zero);
+                    Vector128<T> error = sign & Vector128.LessThan(absValue, Vector128<T>.Zero);
+                    if (error != Vector128<T>.Zero)
+                    {
+                        Math.Abs(int.MinValue); // throw OverflowException
+                    }
+
+                    return Vector128.ConditionalSelect(sign, absValue, -absValue);
+                }
+
+                return x;
+            }
+
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    return Vector256.ConditionalSelect(Vector256.Create(-0.0f).As<float, T>(), y, x);
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector256.ConditionalSelect(Vector256.Create(-0.0d).As<double, T>(), y, x);
+                }
+
+                if (typeof(T) == typeof(sbyte) || typeof(T) == typeof(short) || typeof(T) == typeof(int) || typeof(T) == typeof(long) || typeof(T) == typeof(nint))
+                {
+                    Vector256<T> absValue = Vector256.Abs(x);
+                    Vector256<T> sign = Vector256.GreaterThanOrEqual(y, Vector256<T>.Zero);
+                    Vector256<T> error = sign & Vector256.LessThan(absValue, Vector256<T>.Zero);
+                    if (error != Vector256<T>.Zero)
+                    {
+                        Math.Abs(int.MinValue); // throw OverflowException
+                    }
+
+                    return Vector256.ConditionalSelect(sign, absValue, -absValue);
+                }
+
+                return x;
+            }
+
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    return Vector512.ConditionalSelect(Vector512.Create(-0.0f).As<float, T>(), y, x);
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return Vector512.ConditionalSelect(Vector512.Create(-0.0d).As<double, T>(), y, x);
+                }
+
+                if (typeof(T) == typeof(sbyte) || typeof(T) == typeof(short) || typeof(T) == typeof(int) || typeof(T) == typeof(long) || typeof(T) == typeof(nint))
+                {
+                    Vector512<T> absValue = Vector512.Abs(x);
+                    Vector512<T> sign = Vector512.GreaterThanOrEqual(y, Vector512<T>.Zero);
+                    Vector512<T> error = sign & Vector512.LessThan(absValue, Vector512<T>.Zero);
+                    if (error != Vector512<T>.Zero)
+                    {
+                        Math.Abs(int.MinValue); // throw OverflowException
+                    }
+
+                    return Vector512.ConditionalSelect(sign, absValue, -absValue);
+                }
+
+                return x;
+            }
+        }
+
+        /// <summary>T.DegreesToRadians(x)</summary>
+        internal readonly struct DegreesToRadiansOperator<T> : IUnaryOperator<T> where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => true;
+            public static T Invoke(T x) => T.DegreesToRadians(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => (x * T.Pi) / T.CreateChecked(180);
+            public static Vector256<T> Invoke(Vector256<T> x) => (x * T.Pi) / T.CreateChecked(180);
+            public static Vector512<T> Invoke(Vector512<T> x) => (x * T.Pi) / T.CreateChecked(180);
+        }
+
+        /// <summary>T.RadiansToDegrees(x)</summary>
+        internal readonly struct RadiansToDegreesOperator<T> : IUnaryOperator<T> where T : ITrigonometricFunctions<T>
+        {
+            public static bool Vectorizable => true;
+            public static T Invoke(T x) => T.RadiansToDegrees(x);
+            public static Vector128<T> Invoke(Vector128<T> x) => (x * T.CreateChecked(180)) / T.Pi;
+            public static Vector256<T> Invoke(Vector256<T> x) => (x * T.CreateChecked(180)) / T.Pi;
+            public static Vector512<T> Invoke(Vector512<T> x) => (x * T.CreateChecked(180)) / T.Pi;
+        }
+
         /// <summary>Operator that takes one input value and returns a single value.</summary>
         private interface IUnaryOperator<T>
         {
@@ -13192,6 +14243,7 @@ private interface IUnaryOperator<T>
         /// <summary>Operator that takes two input values and returns a single value.</summary>
         private interface IBinaryOperator<T>
         {
+            static abstract bool Vectorizable { get; }
             static abstract T Invoke(T x, T y);
             static abstract Vector128<T> Invoke(Vector128<T> x, Vector128<T> y);
             static abstract Vector256<T> Invoke(Vector256<T> x, Vector256<T> y);
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netstandard/TensorPrimitives.Single.netstandard.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netstandard/TensorPrimitives.Single.netstandard.cs
index fe32027099c7e3..c9474cb470fd7f 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netstandard/TensorPrimitives.Single.netstandard.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netstandard/TensorPrimitives.Single.netstandard.cs
@@ -808,9 +808,11 @@ private static float MinMaxCore<TMinMaxOperator>(ReadOnlySpan<float> x, TMinMaxO
 
         private static readonly int[] s_0through7 = [0, 1, 2, 3, 4, 5, 6, 7];
 
-        private static int IndexOfMinMaxCore<TIndexOfMinMaxOperator>(ReadOnlySpan<float> x, TIndexOfMinMaxOperator op = default)
+        private static int IndexOfMinMaxCore<T, TIndexOfMinMaxOperator>(ReadOnlySpan<float> x, TIndexOfMinMaxOperator op = default)
             where TIndexOfMinMaxOperator : struct, IIndexOfOperator
         {
+            Debug.Assert(typeof(T) == typeof(float), "The generic parameter exists only to provide the same signature as the generic implementation.");
+
             if (x.IsEmpty)
             {
                 return -1;
@@ -829,7 +831,7 @@ private static int IndexOfMinMaxCore<TIndexOfMinMaxOperator>(ReadOnlySpan<float>
                 ref float xRef = ref MemoryMarshal.GetReference(x);
 
                 Vector<int> resultIndex = new Vector<int>(s_0through7);
-                Vector<int> curIndex = resultIndex;
+                Vector<int> currentIndex = resultIndex;
                 Vector<int> increment = new Vector<int>(Vector<int>.Count);
 
                 // Load the first vector as the initial set of results, and bail immediately
@@ -845,21 +847,21 @@ private static int IndexOfMinMaxCore<TIndexOfMinMaxOperator>(ReadOnlySpan<float>
                     {
                         // Load the next vector, and early exit on NaN.
                         current = AsVector(ref xRef, i);
-                        curIndex = Vector.Add(curIndex, increment);
+                        currentIndex = Vector.Add(currentIndex, increment);
 
                         if (!Vector.EqualsAll(current, current))
                         {
                             goto Scalar;
                         }
 
-                        op.Invoke(ref resultVector, current, ref resultIndex, curIndex);
+                        op.Invoke(ref resultVector, current, ref resultIndex, currentIndex);
                         i += Vector<float>.Count;
                     }
 
                     // If any elements remain, handle them in one final vector.
                     if (i != x.Length)
                     {
-                        curIndex = Vector.Add(curIndex, new Vector<int>(x.Length - i));
+                        currentIndex = Vector.Add(currentIndex, new Vector<int>(x.Length - i));
 
                         current = AsVector(ref xRef, x.Length - Vector<float>.Count);
                         if (!Vector.EqualsAll(current, current))
@@ -867,7 +869,7 @@ private static int IndexOfMinMaxCore<TIndexOfMinMaxOperator>(ReadOnlySpan<float>
                             goto Scalar;
                         }
 
-                        op.Invoke(ref resultVector, current, ref resultIndex, curIndex);
+                        op.Invoke(ref resultVector, current, ref resultIndex, currentIndex);
                     }
 
                     result = op.Invoke(resultVector, resultIndex);
@@ -2966,278 +2968,315 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y)
 
         private interface IIndexOfOperator
         {
-            int Invoke(ref float result, float current, int resultIndex, int curIndex);
+            int Invoke(ref float result, float current, int resultIndex, int currentIndex);
             int Invoke(Vector<float> result, Vector<int> resultIndex);
-            void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<int> resultIndex, Vector<int> curIndex);
+            void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<int> resultIndex, Vector<int> currentIndex);
         }
 
         /// <summary>Returns the index of MathF.Max(x, y)</summary>
         private readonly struct IndexOfMaxOperator_Single : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Invoke(Vector<float> result, Vector<int> resultIndex)
+            public int Invoke(ref float result, float current, int resultIndex, int currentIndex)
             {
-                float curMax = result[0];
-                int curIn = resultIndex[0];
-                for (int i = 1; i < Vector<float>.Count; i++)
+                if (result == current)
                 {
-                    if (result[i] == curMax && IsNegative(curMax) && !IsNegative(result[i]))
-                    {
-                        curMax = result[i];
-                        curIn = resultIndex[i];
-                    }
-                    else if (result[i] > curMax)
+                    bool resultNegative = IsNegative(result);
+                    if ((resultNegative == IsNegative(current)) ? (currentIndex < resultIndex) : resultNegative)
                     {
-                        curMax = result[i];
-                        curIn = resultIndex[i];
+                        result = current;
+                        return currentIndex;
                     }
                 }
+                else if (current > result)
+                {
+                    result = current;
+                    return currentIndex;
+                }
 
-                return curIn;
+                return resultIndex;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<int> resultIndex, Vector<int> curIndex)
+            public int Invoke(Vector<float> current, Vector<int> currentIndex)
             {
-                Vector<int> lessThanMask = Vector.GreaterThan(result, current);
-
-                Vector<int> equalMask = Vector.Equals(result, current);
+                float result = current[0];
+                int resultIndex = currentIndex[0];
 
-                if (equalMask != Vector<int>.Zero)
+                for (int i = 1; i < Vector<float>.Count; i++)
                 {
-                    Vector<float> negativeMask = IsNegative(current);
-                    Vector<int> lessThanIndexMask = Vector.LessThan(resultIndex, curIndex);
-
-                    lessThanMask |= ((Vector<int>)~negativeMask & equalMask) | ((Vector<int>)IsNegative(result) & equalMask & lessThanIndexMask);
+                    if (current[i] == result)
+                    {
+                        bool resultNegative = IsNegative(result);
+                        if ((resultNegative == IsNegative(current[i])) ? (currentIndex[i] < resultIndex) : resultNegative)
+                        {
+                            result = current[i];
+                            resultIndex = currentIndex[i];
+                        }
+                    }
+                    else if (current[i] > result)
+                    {
+                        result = current[i];
+                        resultIndex = currentIndex[i];
+                    }
                 }
 
-                result = Vector.ConditionalSelect(lessThanMask, result, current);
-
-                resultIndex = Vector.ConditionalSelect(lessThanMask, resultIndex, curIndex);
+                return resultIndex;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Invoke(ref float result, float current, int resultIndex, int curIndex)
+            public void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<int> resultIndex, Vector<int> currentIndex)
             {
-                if (result == current)
-                {
-                    if (IsNegative(result) && !IsNegative(current))
-                    {
-                        result = current;
-                        return curIndex;
-                    }
-                }
-                else if (current > result)
+                Vector<int> useResult = Vector.GreaterThan(result, current);
+                Vector<int> equalMask = Vector.Equals(result, current);
+
+                if (equalMask != Vector<int>.Zero)
                 {
-                    result = current;
-                    return curIndex;
+                    // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(current));
+                    Vector<float> currentNegative = IsNegative(current);
+                    useResult |=
+                        equalMask &
+                        Vector.ConditionalSelect(Vector.Equals(IsNegative(result), currentNegative),
+                            Vector.LessThan(resultIndex, currentIndex),
+                            (Vector<int>)currentNegative);
                 }
 
-                return resultIndex;
+                result = Vector.ConditionalSelect(useResult, result, current);
+                resultIndex = Vector.ConditionalSelect(useResult, resultIndex, currentIndex);
             }
         }
 
         private readonly struct IndexOfMaxMagnitudeOperator_Single : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Invoke(ref float result, float current, int resultIndex, int curIndex)
+            public int Invoke(ref float result, float current, int resultIndex, int currentIndex)
             {
-                float curMaxAbs = MathF.Abs(result);
+                float resultAbs = MathF.Abs(result);
                 float currentAbs = MathF.Abs(current);
 
-                if (curMaxAbs == currentAbs)
+                if (resultAbs == currentAbs)
                 {
-                    if (IsNegative(result) && !IsNegative(current))
+                    bool resultNegative = IsNegative(result);
+                    if ((resultNegative == IsNegative(current)) ? (currentIndex < resultIndex) : resultNegative)
                     {
                         result = current;
-                        return curIndex;
+                        return currentIndex;
                     }
                 }
-                else if (currentAbs > curMaxAbs)
+                else if (currentAbs > resultAbs)
                 {
                     result = current;
-                    return curIndex;
+                    return currentIndex;
                 }
 
                 return resultIndex;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Invoke(Vector<float> result, Vector<int> maxIndex)
+            public int Invoke(Vector<float> current, Vector<int> currentIndex)
             {
-                float curMax = result[0];
-                int curIn = maxIndex[0];
+                float result = current[0];
+                float resultAbs = MathF.Abs(result);
+                int resultIndex = currentIndex[0];
+
                 for (int i = 1; i < Vector<float>.Count; i++)
                 {
-                    if (MathF.Abs(result[i]) == MathF.Abs(curMax) && IsNegative(curMax) && !IsNegative(result[i]))
+                    float currentAbs = MathF.Abs(current[i]);
+
+                    if (resultAbs == currentAbs)
                     {
-                        curMax = result[i];
-                        curIn = maxIndex[i];
+                        bool resultNegative = IsNegative(result);
+                        if ((resultNegative == IsNegative(current[i])) ? (currentIndex[i] < resultIndex) : resultNegative)
+                        {
+                            result = current[i];
+                            resultAbs = currentAbs;
+                            resultIndex = currentIndex[i];
+                        }
                     }
-                    else if (MathF.Abs(result[i]) > MathF.Abs(curMax))
+                    else if (currentAbs > resultAbs)
                     {
-                        curMax = result[i];
-                        curIn = maxIndex[i];
+                        result = current[i];
+                        resultAbs = currentAbs;
+                        resultIndex = currentIndex[i];
                     }
                 }
 
-                return curIn;
+                return resultIndex;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<int> resultIndex, Vector<int> curIndex)
+            public void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<int> resultIndex, Vector<int> currentIndex)
             {
-                Vector<float> maxMag = Vector.Abs(result), currentMag = Vector.Abs(current);
-
-                Vector<int> lessThanMask = Vector.GreaterThan(maxMag, currentMag);
-
-                Vector<int> equalMask = Vector.Equals(result, current);
+                Vector<float> resultMag = Vector.Abs(result), currentMag = Vector.Abs(current);
+                Vector<int> useResult = Vector.GreaterThan(resultMag, currentMag);
+                Vector<int> equalMask = Vector.Equals(resultMag, currentMag);
 
                 if (equalMask != Vector<int>.Zero)
                 {
-                    Vector<float> negativeMask = IsNegative(current);
-                    Vector<int> lessThanIndexMask = Vector.LessThan(resultIndex, curIndex);
-
-                    lessThanMask |= ((Vector<int>)~negativeMask & equalMask) | ((Vector<int>)IsNegative(result) & equalMask & lessThanIndexMask);
+                    // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(current));
+                    Vector<float> currentNegative = IsNegative(current);
+                    useResult |=
+                        equalMask &
+                        Vector.ConditionalSelect(Vector.Equals(IsNegative(result), currentNegative),
+                            Vector.LessThan(resultIndex, currentIndex),
+                            (Vector<int>)currentNegative);
                 }
 
-                result = Vector.ConditionalSelect(lessThanMask, result, current);
-
-                resultIndex = Vector.ConditionalSelect(lessThanMask, resultIndex, curIndex);
+                result = Vector.ConditionalSelect(useResult, result, current);
+                resultIndex = Vector.ConditionalSelect(useResult, resultIndex, currentIndex);
             }
         }
 
         private readonly struct IndexOfMinOperator_Single : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Invoke(ref float result, float current, int resultIndex, int curIndex)
+            public int Invoke(ref float result, float current, int resultIndex, int currentIndex)
             {
                 if (result == current)
                 {
-                    if (IsPositive(result) && !IsPositive(current))
+                    bool currentNegative = IsNegative(current);
+                    if ((IsNegative(result) == currentNegative) ? (currentIndex < resultIndex) : currentNegative)
                     {
                         result = current;
-                        return curIndex;
+                        return currentIndex;
                     }
                 }
                 else if (current < result)
                 {
                     result = current;
-                    return curIndex;
+                    return currentIndex;
                 }
 
                 return resultIndex;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Invoke(Vector<float> result, Vector<int> resultIndex)
+            public int Invoke(Vector<float> current, Vector<int> currentIndex)
             {
-                float curMin = result[0];
-                int curIn = resultIndex[0];
+                float result = current[0];
+                int resultIndex = currentIndex[0];
+
                 for (int i = 1; i < Vector<float>.Count; i++)
                 {
-                    if (result[i] == curMin && IsPositive(curMin) && !IsPositive(result[i]))
+                    if (current[i] == result)
                     {
-                        curMin = result[i];
-                        curIn = resultIndex[i];
+                        bool currentNegative = IsNegative(current[i]);
+                        if ((IsNegative(result) == currentNegative) ? (currentIndex[i] < resultIndex) : currentNegative)
+                        {
+                            result = current[i];
+                            resultIndex = currentIndex[i];
+                        }
                     }
-                    else if (result[i] < curMin)
+                    else if (current[i] < result)
                     {
-                        curMin = result[i];
-                        curIn = resultIndex[i];
+                        result = current[i];
+                        resultIndex = currentIndex[i];
                     }
                 }
 
-                return curIn;
+                return resultIndex;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<int> resultIndex, Vector<int> curIndex)
+            public void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<int> resultIndex, Vector<int> currentIndex)
             {
-                Vector<int> lessThanMask = Vector.LessThan(result, current);
-
+                Vector<int> useResult = Vector.LessThan(result, current);
                 Vector<int> equalMask = Vector.Equals(result, current);
 
                 if (equalMask != Vector<int>.Zero)
                 {
-                    Vector<float> negativeMask = IsNegative(current);
-                    Vector<int> lessThanIndexMask = Vector.LessThan(resultIndex, curIndex);
-
-                    lessThanMask |= ((Vector<int>)negativeMask & equalMask) | (~(Vector<int>)IsNegative(result) & equalMask & lessThanIndexMask);
+                    // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(result));
+                    Vector<float> resultNegative = IsNegative(result);
+                    useResult |=
+                        equalMask &
+                        Vector.ConditionalSelect(Vector.Equals(resultNegative, IsNegative(current)),
+                            Vector.LessThan(resultIndex, currentIndex),
+                            (Vector<int>)resultNegative);
                 }
 
-                result = Vector.ConditionalSelect(lessThanMask, result, current);
-
-                resultIndex = Vector.ConditionalSelect(lessThanMask, resultIndex, curIndex);
+                result = Vector.ConditionalSelect(useResult, result, current);
+                resultIndex = Vector.ConditionalSelect(useResult, resultIndex, currentIndex);
             }
         }
 
         private readonly struct IndexOfMinMagnitudeOperator_Single : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Invoke(ref float result, float current, int resultIndex, int curIndex)
+            public int Invoke(ref float result, float current, int resultIndex, int currentIndex)
             {
-                float curMinAbs = MathF.Abs(result);
+                float resultAbs = MathF.Abs(result);
                 float currentAbs = MathF.Abs(current);
-                if (curMinAbs == currentAbs)
+
+                if (resultAbs == currentAbs)
                 {
-                    if (IsPositive(result) && !IsPositive(current))
+                    bool currentNegative = IsNegative(current);
+                    if ((IsNegative(result) == currentNegative) ? (currentIndex < resultIndex) : currentNegative)
                     {
                         result = current;
-                        return curIndex;
+                        return currentIndex;
                     }
                 }
-                else if (currentAbs < curMinAbs)
+                else if (currentAbs < resultAbs)
                 {
                     result = current;
-                    return curIndex;
+                    return currentIndex;
                 }
 
                 return resultIndex;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int Invoke(Vector<float> result, Vector<int> resultIndex)
+            public int Invoke(Vector<float> current, Vector<int> currentIndex)
             {
-                float curMin = result[0];
-                int curIn = resultIndex[0];
+                float result = current[0];
+                float resultAbs = MathF.Abs(result);
+                int resultIndex = currentIndex[0];
+
                 for (int i = 1; i < Vector<float>.Count; i++)
                 {
-                    if (MathF.Abs(result[i]) == MathF.Abs(curMin) && IsPositive(curMin) && !IsPositive(result[i]))
+                    float currentAbs = MathF.Abs(current[i]);
+
+                    if (resultAbs == currentAbs)
                     {
-                        curMin = result[i];
-                        curIn = resultIndex[i];
+                        bool currentNegative = IsNegative(current[i]);
+                        if ((IsNegative(result) == currentNegative) ? (currentIndex[i] < resultIndex) : currentNegative)
+                        {
+                            result = current[i];
+                            resultAbs = currentAbs;
+                            resultIndex = currentIndex[i];
+                        }
                     }
-                    else if (MathF.Abs(result[i]) < MathF.Abs(curMin))
+                    else if (currentAbs < resultAbs)
                     {
-                        curMin = result[i];
-                        curIn = resultIndex[i];
+                        result = current[i];
+                        resultAbs = currentAbs;
+                        resultIndex = currentIndex[i];
                     }
                 }
 
-                return curIn;
+                return resultIndex;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<int> resultIndex, Vector<int> curIndex)
+            public void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<int> resultIndex, Vector<int> currentIndex)
             {
-                Vector<float> minMag = Vector.Abs(result), currentMag = Vector.Abs(current);
-
-                Vector<int> lessThanMask = Vector.LessThan(minMag, currentMag);
-
-                Vector<int> equalMask = Vector.Equals(result, current);
+                Vector<float> resultMag = Vector.Abs(result), currentMag = Vector.Abs(current);
+                Vector<int> useResult = Vector.LessThan(resultMag, currentMag);
+                Vector<int> equalMask = Vector.Equals(resultMag, currentMag);
 
                 if (equalMask != Vector<int>.Zero)
                 {
-                    Vector<float> negativeMask = IsNegative(current);
-                    Vector<int> lessThanIndexMask = Vector.LessThan(resultIndex, curIndex);
-
-                    lessThanMask |= ((Vector<int>)negativeMask & equalMask) | (~(Vector<int>)IsNegative(result) & equalMask & lessThanIndexMask);
+                    // bool useResult = equal && ((IsNegative(result) == IsNegative(current)) ? (resultIndex < currentIndex) : IsNegative(result));
+                    Vector<float> resultNegative = IsNegative(result);
+                    useResult |=
+                        equalMask &
+                        Vector.ConditionalSelect(Vector.Equals(resultNegative, IsNegative(current)),
+                            Vector.LessThan(resultIndex, currentIndex),
+                            (Vector<int>)resultNegative);
                 }
 
-                result = Vector.ConditionalSelect(lessThanMask, result, current);
-
-                resultIndex = Vector.ConditionalSelect(lessThanMask, resultIndex, curIndex);
+                result = Vector.ConditionalSelect(useResult, result, current);
+                resultIndex = Vector.ConditionalSelect(useResult, resultIndex, currentIndex);
             }
         }
 
diff --git a/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs b/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs
index 272991aed44ab8..380add4727e8d2 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs
@@ -9,7 +9,11 @@ internal static class ThrowHelper
     {
         [DoesNotReturn]
         public static void ThrowArgument_DestinationTooShort() =>
-            throw new ArgumentException(SR.Argument_DestinationTooShort, "destination");
+            ThrowArgument_DestinationTooShort("destination");
+
+        [DoesNotReturn]
+        public static void ThrowArgument_DestinationTooShort(string destinationName) =>
+            throw new ArgumentException(SR.Argument_DestinationTooShort, destinationName);
 
         [DoesNotReturn]
         public static void ThrowArgument_SpansMustHaveSameLength() =>
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
index de0269ca889246..65c45de4c42556 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
@@ -8,6 +8,11 @@
 using Xunit;
 using Xunit.Sdk;
 
+// Tests specific to .NET Core generic APIs.
+// Some of the tests are written with functionality abstracted into helpers that provide the core operation: this
+// is done when the tests are shared with legacy float-specific tests. Tests that don't need to be shared access
+// the generic APIs directly.
+
 namespace System.Numerics.Tensors.Tests
 {
     public class DoubleGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<double> { }
@@ -30,6 +35,7 @@ public class UInt16GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests
     public class CharGenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<char> { }
     public class UInt32GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<uint> { }
     public class UInt64GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<ulong> { }
+
     public class UIntPtrGenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<nuint> { }
     public class UInt128GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<UInt128> { }
 
@@ -113,11 +119,953 @@ protected override void SetSpecialValues(Span<T> x, Span<T> y)
             x[pos] = T.Epsilon;
             y[pos] = -T.Epsilon;
 
-            // Same magnitude, opposite sign
-            pos = Random.Next(x.Length);
-            x[pos] = T.CreateTruncating(5);
-            y[pos] = T.CreateTruncating(-5);
+            // Same magnitude, opposite sign
+            pos = Random.Next(x.Length);
+            x[pos] = T.CreateTruncating(5);
+            y[pos] = T.CreateTruncating(-5);
+        }
+
+        #region Span -> Destination
+        public static IEnumerable<object[]> SpanDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Acosh), new Func<T, T>(T.Acosh) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.AcosPi), new Func<T, T>(T.AcosPi) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Acos), new Func<T, T>(T.Acos) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Asinh), new Func<T, T>(T.Asinh) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.AsinPi), new Func<T, T>(T.AsinPi) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Asin), new Func<T, T>(T.Asin) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Atanh), new Func<T, T>(T.Atanh) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.AtanPi), new Func<T, T>(T.AtanPi) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Atan), new Func<T, T>(T.Atan) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Cbrt), new Func<T, T>(T.Cbrt) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Ceiling), new Func<T, T>(T.Ceiling) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Cos), new Func<T, T>(T.Cos) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Cosh), new Func<T, T>(T.Cosh) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.CosPi), new Func<T, T>(T.CosPi) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.DegreesToRadians), new Func<T, T>(T.DegreesToRadians) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Exp), new Func<T, T>(T.Exp) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Exp2), new Func<T, T>(T.Exp2) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Exp10), new Func<T, T>(T.Exp10) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.ExpM1), new Func<T, T>(T.ExpM1) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Exp2M1), new Func<T, T>(T.Exp2M1) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Exp10M1), new Func<T, T>(T.Exp10M1) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Floor), new Func<T, T>(T.Floor) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Log), new Func<T, T>(T.Log) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Log2), new Func<T, T>(T.Log2) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Log10), new Func<T, T>(T.Log10) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.LogP1), new Func<T, T>(T.LogP1) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Log2P1), new Func<T, T>(T.Log2P1) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Log10P1), new Func<T, T>(T.Log10P1) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.RadiansToDegrees), new Func<T, T>(T.RadiansToDegrees) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Reciprocal), new Func<T, T>(f => T.One / f) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.ReciprocalEstimate), new Func<T, T>(T.ReciprocalEstimate) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.ReciprocalSqrt), new Func<T, T>(f => T.One / T.Sqrt(f)) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.ReciprocalSqrtEstimate), new Func<T, T>(T.ReciprocalSqrtEstimate) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Round), new Func<T, T>(T.Round) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Sin), new Func<T, T>(T.Sin) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Sinh), new Func<T, T>(T.Sinh) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.SinPi), new Func<T, T>(T.SinPi) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Sqrt), new Func<T, T>(T.Sqrt) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Tan), new Func<T, T>(T.Tan) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Tanh), new Func<T, T>(T.Tanh) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.TanPi), new Func<T, T>(T.TanPi) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.Truncate), new Func<T, T>(T.Truncate) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationFunctionsToTest))]
+        public void SpanDestinationFunctions_AllLengths(SpanDestinationDelegate tensorPrimitivesMethod, Func<T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x.Span, destination.Span);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x[i]), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationFunctionsToTest))]
+        public void SpanDestinationFunctions_InPlace(SpanDestinationDelegate tensorPrimitivesMethod, Func<T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+
+                tensorPrimitivesMethod(x.Span, x.Span);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(xOrig[i]), x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationFunctionsToTest))]
+        public void SpanDestinationFunctions_SpecialValues(SpanDestinationDelegate tensorPrimitivesMethod, Func<T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                RunForEachSpecialValue(() =>
+                {
+                    tensorPrimitivesMethod(x.Span, destination.Span);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(expectedMethod(x[i]), destination[i]);
+                    }
+                }, x);
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationFunctionsToTest))]
+        public void SpanDestinationFunctions_ValueRange(SpanDestinationDelegate tensorPrimitivesMethod, Func<T, T> expectedMethod)
+        {
+            Assert.All(VectorLengthAndIteratedRange(ConvertFromSingle(-100f), ConvertFromSingle(100f), ConvertFromSingle(3f)), arg =>
+            {
+                T[] x = new T[arg.Length];
+                T[] dest = new T[arg.Length];
+
+                x.AsSpan().Fill(arg.Element);
+                tensorPrimitivesMethod(x.AsSpan(), dest.AsSpan());
+
+                T expected = expectedMethod(arg.Element);
+                foreach (T actual in dest)
+                {
+                    AssertEqualTolerance(expected, actual);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationFunctionsToTest))]
+        public void SpanDestinationFunctions_ThrowsForTooShortDestination(SpanDestinationDelegate tensorPrimitivesMethod, Func<T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x.Span, destination.Span));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationFunctionsToTest))]
+        public void SpanDestinationFunctions_ThrowsForOverlapppingInputsWithOutputs(SpanDestinationDelegate tensorPrimitivesMethod, Func<T, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(2, 2)));
+        }
+        #endregion
+
+        #region Span,Span -> Destination
+        public static IEnumerable<object[]> SpanSpanDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanSpanDestinationDelegate(TensorPrimitives.Atan2), new Func<T, T, T>(T.Atan2) };
+            yield return new object[] { new SpanSpanDestinationDelegate(TensorPrimitives.Atan2Pi), new Func<T, T, T>(T.Atan2Pi) };
+            yield return new object[] { new SpanSpanDestinationDelegate(TensorPrimitives.CopySign), new Func<T, T, T>(T.CopySign) };
+            yield return new object[] { new SpanSpanDestinationDelegate(TensorPrimitives.Hypot), new Func<T, T, T>(T.Hypot) };
+            yield return new object[] { new SpanSpanDestinationDelegate(TensorPrimitives.Ieee754Remainder), new Func<T, T, T>(T.Ieee754Remainder) };
+            yield return new object[] { new SpanSpanDestinationDelegate(TensorPrimitives.Log), new Func<T, T, T>(T.Log) };
+            yield return new object[] { new SpanSpanDestinationDelegate(TensorPrimitives.Pow), new Func<T, T, T>(T.Pow) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanDestination_AllLengths(SpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x[i], y[i]), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanDestination_InPlace(SpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+
+                tensorPrimitivesMethod(x, x, x);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(xOrig[i], xOrig[i]), x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanDestination_ThrowsForMismatchedLengths(SpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(x, y, destination));
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(y, x, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanDestination_ThrowsForTooShortDestination(SpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, y, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanDestination_ThrowsForOverlapppingInputsWithOutputs(SpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(4, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(6, 2)));
+        }
+        #endregion
+
+        #region Span,Scalar -> Destination
+        public static IEnumerable<object[]> SpanScalarDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.Atan2), new Func<T, T, T>(T.Atan2) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.Atan2Pi), new Func<T, T, T>(T.Atan2Pi) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.CopySign), new Func<T, T, T>(T.CopySign) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.Ieee754Remainder), new Func<T, T, T>(T.Ieee754Remainder) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.Pow), new Func<T, T, T>(T.Pow) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.Log), new Func<T, T, T>(T.Log) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.Max), new Func<T, T, T>(T.Max) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.MaxMagnitude), new Func<T, T, T>(T.MaxMagnitude) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.Min), new Func<T, T, T>(T.Min) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.MinMagnitude), new Func<T, T, T>(T.MinMagnitude) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarDestinationFunctionsToTest))]
+        public void SpanScalarDestination_AllLengths(SpanScalarDestinationDelegate<T, T, T> tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x[i], y), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarDestinationFunctionsToTest))]
+        public void SpanScalarDestination_InPlace(SpanScalarDestinationDelegate<T, T, T> tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                T[] xOrig = x.Span.ToArray();
+
+                tensorPrimitivesMethod(x, y, x);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(xOrig[i], y), x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarDestinationFunctionsToTest))]
+        public void SpanScalarDestination_ThrowsForTooShortDestination(SpanScalarDestinationDelegate<T, T, T> tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, y, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarDestinationFunctionsToTest))]
+        public void SpanScalarDestination_ThrowsForOverlapppingInputsWithOutputs(SpanScalarDestinationDelegate<T, T, T> tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), default, array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), default, array.AsSpan(2, 2)));
+        }
+        #endregion
+
+        #region Scalar,Span -> Destination
+        public static IEnumerable<object[]> ScalarSpanFloatDestinationFunctionsToTest()
+        {
+            yield return new object[] { new ScalarSpanDestinationDelegate(TensorPrimitives.Atan2), new Func<T, T, T>(T.Atan2) };
+            yield return new object[] { new ScalarSpanDestinationDelegate(TensorPrimitives.Atan2Pi), new Func<T, T, T>(T.Atan2Pi) };
+            yield return new object[] { new ScalarSpanDestinationDelegate(TensorPrimitives.Pow), new Func<T, T, T>(T.Pow) };
+            yield return new object[] { new ScalarSpanDestinationDelegate(TensorPrimitives.Ieee754Remainder), new Func<T, T, T>(T.Ieee754Remainder) };
+        }
+
+        [Theory]
+        [MemberData(nameof(ScalarSpanFloatDestinationFunctionsToTest))]
+        public void SpanScalarFloatDestination_AllLengths(ScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                T x = NextRandom();
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x, y[i]), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ScalarSpanFloatDestinationFunctionsToTest))]
+        public void SpanScalarFloatDestination_InPlace(ScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                T x = NextRandom();
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                T[] yOrig = y.Span.ToArray();
+
+                tensorPrimitivesMethod(x, y, y);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x, yOrig[i]), y[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ScalarSpanFloatDestinationFunctionsToTest))]
+        public void SpanScalarFloatDestination_ThrowsForTooShortDestination(ScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                T x = NextRandom();
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, y, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ScalarSpanFloatDestinationFunctionsToTest))]
+        public void SpanScalarFloatDestination_ThrowsForOverlapppingInputsWithOutputs(ScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(default, array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(default, array.AsSpan(1, 2), array.AsSpan(2, 2)));
+        }
+        #endregion
+
+        #region Span,Int,Span -> Destination
+        public static IEnumerable<object[]> SpanIntDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanScalarDestinationDelegate<T, int, T>(TensorPrimitives.RootN), new Func<T, int, T>(T.RootN) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, int, T>(TensorPrimitives.ScaleB), new Func<T, int, T>(T.ScaleB) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanIntDestinationFunctionsToTest))]
+        public void SpanIntDestination_AllLengths(SpanScalarDestinationDelegate<T, int, T> tensorPrimitivesMethod, Func<T, int, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                int y = Random.Next(1, 10);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x[i], y), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanIntDestinationFunctionsToTest))]
+        public void SpanIntDestination_InPlace(SpanScalarDestinationDelegate<T, int, T> tensorPrimitivesMethod, Func<T, int, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                int y = Random.Next(1, 10);
+
+                tensorPrimitivesMethod(x, y, x);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(xOrig[i], y), x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanIntDestinationFunctionsToTest))]
+        public void SpanIntDestination_ThrowsForTooShortDestination(SpanScalarDestinationDelegate<T, int, T> tensorPrimitivesMethod, Func<T, int, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                int y = 2;
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, y, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanIntDestinationFunctionsToTest))]
+        public void SpanIntDestination_ThrowsForOverlapppingInputsWithOutputs(SpanScalarDestinationDelegate<T, int, T> tensorPrimitivesMethod, Func<T, int, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), 2, array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), 2, array.AsSpan(2, 2)));
+        }
+        #endregion
+
+        #region Span,Span,Span -> Destination
+        public static IEnumerable<object[]> SpanSpanSpanDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanSpanSpanDestinationDelegate(TensorPrimitives.Lerp), new Func<T, T, T, T>(T.Lerp) };
+            yield return new object[] { new SpanSpanSpanDestinationDelegate(TensorPrimitives.FusedMultiplyAdd), new Func<T, T, T, T>(T.FusedMultiplyAdd) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanSpanDestination_AllLengths(SpanSpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> z = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, y, z, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x[i], y[i], z[i]), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanSpanDestination_InPlace(SpanSpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+
+                tensorPrimitivesMethod(x, x, x, x);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(xOrig[i], xOrig[i], xOrig[i]), x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanSpanDestination_ThrowsForMismatchedLengths(SpanSpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> z = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(x, y, z, destination));
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(x, z, y, destination));
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(y, x, z, destination));
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(y, z, x, destination));
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(z, x, y, destination));
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(z, y, x, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanSpanDestination_ThrowsForTooShortDestination(SpanSpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> z = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, y, z, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanSpanDestination_ThrowsForOverlapppingInputsWithOutputs(SpanSpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(7, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(7, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(7, 2), array.AsSpan(4, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(7, 2), array.AsSpan(6, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(7, 2), array.AsSpan(8, 2)));
+        }
+        #endregion
+
+        #region Span,Span,Scalar -> Destination
+        public static IEnumerable<object[]> SpanSpanScalarDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanSpanScalarDestinationDelegate(TensorPrimitives.FusedMultiplyAdd), new Func<T, T, T, T>(T.FusedMultiplyAdd) };
+            yield return new object[] { new SpanSpanScalarDestinationDelegate(TensorPrimitives.Lerp), new Func<T, T, T, T>(T.Lerp) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanScalarDestinationFunctionsToTest))]
+        public void SpanSpanScalarDestination_AllLengths(SpanSpanScalarDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                T z = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, y, z, destination);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x[i], y[i], z), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanScalarDestinationFunctionsToTest))]
+        public void SpanSpanScalarDestination_InPlace(SpanSpanScalarDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                T z = NextRandom();
+
+                tensorPrimitivesMethod(x, x, z, x);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(xOrig[i], xOrig[i], z), x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanScalarDestinationFunctionsToTest))]
+        public void SpanSpanScalarDestination_ThrowsForTooShortDestination(SpanSpanScalarDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                T z = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, y, z, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanScalarDestinationFunctionsToTest))]
+        public void SpanSpanScalarDestination_ThrowsForOverlapppingInputsWithOutputs(SpanSpanScalarDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(4, 2), default, array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(4, 2), default, array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(4, 2), default, array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(4, 2), default, array.AsSpan(5, 2)));
+        }
+        #endregion
+
+        #region Span,Scalar,Span -> Destination
+        public static IEnumerable<object[]> SpanScalarSpanDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanScalarSpanDestinationDelegate(TensorPrimitives.FusedMultiplyAdd), new Func<T, T, T, T>(T.FusedMultiplyAdd) };
+            yield return new object[] { new SpanScalarSpanDestinationDelegate(TensorPrimitives.Lerp), new Func<T, T, T, T>(T.Lerp) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarSpanDestinationFunctionsToTest))]
+        public void SpanScalarSpanDestination_AllLengths(SpanScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> z = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, y, z, destination);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x[i], y, z[i]), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarSpanDestinationFunctionsToTest))]
+        public void SpanScalarSpanDestination_InPlace(SpanScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                T y = NextRandom();
+
+                tensorPrimitivesMethod(x, y, x, x);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(xOrig[i], y, xOrig[i]), x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarSpanDestinationFunctionsToTest))]
+        public void SpanScalarSpanDestination_ThrowsForTooShortDestination(SpanScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> z = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, y, z, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarSpanDestinationFunctionsToTest))]
+        public void SpanScalarSpanDestination_ThrowsForOverlapppingInputsWithOutputs(SpanScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), default, array.AsSpan(4, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), default, array.AsSpan(4, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), default, array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), default, array.AsSpan(4, 2), array.AsSpan(5, 2)));
+        }
+        #endregion
+
+        #region Span -> Destination,Destination
+        public static IEnumerable<object[]> SpanDestinationDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanDestinationDestinationDelegate(TensorPrimitives.SinCos), new Func<T, (T, T)>(T.SinCos) };
+            yield return new object[] { new SpanDestinationDestinationDelegate(TensorPrimitives.SinCosPi), new Func<T, (T, T)>(T.SinCosPi) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationDestinationFunctionsToTest))]
+        public void SpanDestinationDestinationFunctions_AllLengths(SpanDestinationDestinationDelegate tensorPrimitivesMethod, Func<T, (T, T)> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination1 = CreateTensor(tensorLength);
+                using BoundedMemory<T> destination2 = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x.Span, destination1.Span, destination2.Span);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    (T expected1, T expected2) = expectedMethod(x[i]);
+                    AssertEqualTolerance(expected1, destination1[i]);
+                    AssertEqualTolerance(expected2, destination2[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationDestinationFunctionsToTest))]
+        public void SpanDestinationDestinationFunctions_InPlace(SpanDestinationDestinationDelegate tensorPrimitivesMethod, Func<T, (T, T)> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                using BoundedMemory<T> destination2 = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x.Span, x.Span, destination2.Span);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    (T expected1, T expected2) = expectedMethod(xOrig[i]);
+                    AssertEqualTolerance(expected1, x[i]);
+                    AssertEqualTolerance(expected2, destination2[i]);
+                }
+            });
+
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                using BoundedMemory<T> destination1 = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x.Span, destination1.Span, x.Span);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    (T expected1, T expected2) = expectedMethod(xOrig[i]);
+                    AssertEqualTolerance(expected1, destination1[i]);
+                    AssertEqualTolerance(expected2, x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationDestinationFunctionsToTest))]
+        public void SpanDestinationDestinationFunctions_SpecialValues(SpanDestinationDestinationDelegate tensorPrimitivesMethod, Func<T, (T, T)> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination1 = CreateTensor(tensorLength);
+                using BoundedMemory<T> destination2 = CreateTensor(tensorLength);
+
+                RunForEachSpecialValue(() =>
+                {
+                    tensorPrimitivesMethod(x.Span, destination1.Span, destination2.Span);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        (T expected1, T expected2) = expectedMethod(x[i]);
+                        AssertEqualTolerance(expected1, destination1[i]);
+                        AssertEqualTolerance(expected2, destination2[i]);
+                    }
+                }, x);
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationDestinationFunctionsToTest))]
+        public void SpanDestinationDestinationFunctions_ValueRange(SpanDestinationDestinationDelegate tensorPrimitivesMethod, Func<T, (T, T)> expectedMethod)
+        {
+            Assert.All(VectorLengthAndIteratedRange(ConvertFromSingle(-100f), ConvertFromSingle(100f), ConvertFromSingle(3f)), arg =>
+            {
+                T[] x = new T[arg.Length];
+                T[] dest1 = new T[arg.Length];
+                T[] dest2 = new T[arg.Length];
+
+                x.AsSpan().Fill(arg.Element);
+                tensorPrimitivesMethod(x.AsSpan(), dest1.AsSpan(), dest2.AsSpan());
+
+                (T expected1, T expected2) = expectedMethod(arg.Element);
+                foreach (T actual in dest1)
+                {
+                    AssertEqualTolerance(expected1, actual);
+                }
+                foreach (T actual in dest2)
+                {
+                    AssertEqualTolerance(expected2, actual);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationDestinationFunctionsToTest))]
+        public void SpanDestinationDestinationFunctions_ThrowsForTooShortDestination(SpanDestinationDestinationDelegate tensorPrimitivesMethod, Func<T, (T, T)> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination1 = CreateTensor(tensorLength - 1);
+                using BoundedMemory<T> destination2 = CreateTensor(tensorLength);
+
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(x.Span, destination1.Span, destination2.Span));
+            });
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination1 = CreateTensor(tensorLength);
+                using BoundedMemory<T> destination2 = CreateTensor(tensorLength - 1);
+
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(x.Span, destination1.Span, destination2.Span));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationDestinationFunctionsToTest))]
+        public void SpanDestinationDestinationFunctions_ThrowsForOverlapppingInputsWithOutputs(SpanDestinationDestinationDelegate tensorPrimitivesMethod, Func<T, (T, T)> _)
+        {
+            T[] array = new T[10];
+            Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(0, 2), array.AsSpan(4, 2)));
+            Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(2, 2), array.AsSpan(4, 2)));
+            Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(array.AsSpan(3, 2), array.AsSpan(0, 2), array.AsSpan(4, 2)));
+            Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(array.AsSpan(5, 2), array.AsSpan(0, 2), array.AsSpan(4, 2)));
+        }
+        #endregion
+
+        #region ILogB
+        [Fact]
+        public void ILogB_AllLengths()
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<int> destination = BoundedMemory.Allocate<int>(tensorLength);
+
+                TensorPrimitives.ILogB<T>(x.Span, destination.Span);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(T.CreateTruncating(T.ILogB(x[i])), T.CreateTruncating(destination[i]));
+                }
+            });
+        }
+
+        [Fact]
+        public void ILogB_SpecialValues()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<int> destination = BoundedMemory.Allocate<int>(tensorLength);
+
+                RunForEachSpecialValue(() =>
+                {
+                    TensorPrimitives.ILogB<T>(x.Span, destination.Span);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(T.CreateTruncating(T.ILogB(x[i])), T.CreateTruncating(destination[i]));
+                    }
+                }, x);
+            });
+        }
+
+        [Fact]
+        public void ILogB_ThrowsForTooShortDestination()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<int> destination = BoundedMemory.Allocate<int>(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.ILogB<T>(x.Span, destination.Span));
+            });
+        }
+        #endregion
+
+        #region Round
+        public static IEnumerable<object[]> RoundData()
+        {
+            foreach (MidpointRounding mode in Enum.GetValues(typeof(MidpointRounding)))
+            {
+                foreach (int digits in new[] { 0, 1, 4 })
+                {
+                    yield return new object[] { mode, digits };
+                }
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(RoundData))]
+        public void Round_AllLengths(MidpointRounding mode, int digits)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                if (digits == 0)
+                {
+                    if (mode == MidpointRounding.ToEven)
+                    {
+                        TensorPrimitives.Round(x.Span, destination.Span);
+                        for (int i = 0; i < tensorLength; i++)
+                        {
+                            AssertEqualTolerance(T.Round(x[i]), destination[i]);
+                        }
+                    }
+
+                    TensorPrimitives.Round(x.Span, mode, destination.Span);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(T.Round(x[i], mode), destination[i]);
+                    }
+                }
+
+                if (mode == MidpointRounding.ToEven)
+                {
+                    TensorPrimitives.Round(x.Span, digits, destination.Span);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(T.Round(x[i], digits), destination[i]);
+                    }
+                }
+
+                TensorPrimitives.Round(x.Span, digits, mode, destination.Span);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(T.Round(x[i], digits, mode), destination[i]);
+                }
+            });
         }
+        #endregion
     }
 
     public unsafe abstract class GenericSignedIntegerTensorPrimitivesTests<T> : GenericIntegerTensorPrimitivesTests<T>
@@ -134,7 +1082,7 @@ public void Abs_MinValue_Throws()
                 FillTensor(x.Span, T.MinValue);
                 x[^1] = T.MinValue;
 
-                Assert.Throws<OverflowException>(() => Abs(x, destination));
+                Assert.Throws<OverflowException>(() => TensorPrimitives.Abs(x.Span, destination.Span));
             });
         }
 
@@ -148,7 +1096,7 @@ public void SumOfMagnitudes_MinValue_Throws()
                 FillTensor(x.Span, T.MinValue);
                 x[^1] = T.MinValue;
 
-                Assert.Throws<OverflowException>(() => SumOfMagnitudes(x));
+                Assert.Throws<OverflowException>(() => TensorPrimitives.SumOfMagnitudes<T>(x.Span));
             });
         }
     }
@@ -168,8 +1116,7 @@ public void Divide_TwoTensors_ByZero_Throws()
                 FillTensor(y.Span, T.Zero);
                 y[^1] = T.Zero;
 
-                Exception e = Record.Exception(() => Divide(x, y, destination));
-                Assert.True(e is DivideByZeroException or ArgumentOutOfRangeException); // TODO https://github.com/dotnet/runtime/issues/94593: Fix exception type
+                Assert.Throws<DivideByZeroException>(() => TensorPrimitives.Divide(x.Span, y.Span, destination.Span));
             });
         }
 
@@ -181,10 +1128,420 @@ public void Divide_TensorScalar_ByZero_Throw()
                 using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
                 using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-                Exception e = Record.Exception(() => Divide(x, T.Zero, destination));
-                Assert.True(e is DivideByZeroException or ArgumentOutOfRangeException); // TODO https://github.com/dotnet/runtime/issues/94593: Fix exception type
+                Assert.Throws<DivideByZeroException>(() => TensorPrimitives.Divide(x, T.Zero, destination));
+            });
+        }
+
+        [Fact]
+        public void Divide_ScalarTensor_ByZero_Throw()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+                x[Random.Next(x.Length)] = T.Zero;
+
+                Assert.Throws<DivideByZeroException>(() => TensorPrimitives.Divide(T.One, x, destination));
+            });
+        }
+
+        #region Span -> Destination
+        public static IEnumerable<object[]> SpanDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.OnesComplement), new Func<T, T>(i => ~i) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.PopCount), new Func<T, T>(T.PopCount) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.LeadingZeroCount), new Func<T, T>(T.LeadingZeroCount) };
+            yield return new object[] { new SpanDestinationDelegate(TensorPrimitives.TrailingZeroCount), new Func<T, T>(T.TrailingZeroCount) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationFunctionsToTest))]
+        public void SpanDestinationFunctions_AllLengths(SpanDestinationDelegate tensorPrimitivesMethod, Func<T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, destination);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x[i]), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationFunctionsToTest))]
+        public void SpanDestinationFunctions_InPlace(SpanDestinationDelegate tensorPrimitivesMethod, Func<T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+
+                tensorPrimitivesMethod(x, x);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(xOrig[i]), x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationFunctionsToTest))]
+        public void SpanDestinationFunctions_ThrowsForTooShortDestination(SpanDestinationDelegate tensorPrimitivesMethod, Func<T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanDestinationFunctionsToTest))]
+        public void SpanDestinationFunctions_ThrowsForOverlapppingInputsWithOutputs(SpanDestinationDelegate tensorPrimitivesMethod, Func<T, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(2, 2)));
+        }
+        #endregion
+
+        #region Span,Span -> Destination
+        public static IEnumerable<object[]> SpanSpanDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanSpanDestinationDelegate(TensorPrimitives.BitwiseAnd), new Func<T, T, T>((x, y) => x & y) };
+            yield return new object[] { new SpanSpanDestinationDelegate(TensorPrimitives.BitwiseOr), new Func<T, T, T>((x, y) => x | y) };
+            yield return new object[] { new SpanSpanDestinationDelegate(TensorPrimitives.Xor), new Func<T, T, T>((x, y) => x ^ y) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanDestination_AllLengths(SpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x[i], y[i]), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanDestination_InPlace(SpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+
+                tensorPrimitivesMethod(x, x, x);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(xOrig[i], xOrig[i]), x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanDestination_ThrowsForMismatchedLengths(SpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(x, y, destination));
+                Assert.Throws<ArgumentException>(() => tensorPrimitivesMethod(y, x, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanDestination_ThrowsForTooShortDestination(SpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, y, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanSpanDestinationFunctionsToTest))]
+        public void SpanSpanDestination_ThrowsForOverlapppingInputsWithOutputs(SpanSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(4, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(6, 2)));
+        }
+        #endregion
+
+        #region Span,Scalar -> Destination
+        public static IEnumerable<object[]> SpanScalarDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.BitwiseAnd), new Func<T, T, T>((x, y) => x & y) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.BitwiseOr), new Func<T, T, T>((x, y) => x | y) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.Max), new Func<T, T, T>(T.Max) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.MaxMagnitude), new Func<T, T, T>(T.MaxMagnitude) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.Min), new Func<T, T, T>(T.Min) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.MinMagnitude), new Func<T, T, T>(T.MinMagnitude) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, T, T>(TensorPrimitives.Xor), new Func<T, T, T>((x, y) => x ^ y) };
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarDestinationFunctionsToTest))]
+        public void SpanScalarDestination_AllLengths(SpanScalarDestinationDelegate<T, T, T> tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x[i], y), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarDestinationFunctionsToTest))]
+        public void SpanScalarDestination_InPlace(SpanScalarDestinationDelegate<T, T, T> tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                T[] xOrig = x.Span.ToArray();
+
+                tensorPrimitivesMethod(x, y, x);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(xOrig[i], y), x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarDestinationFunctionsToTest))]
+        public void SpanScalarDestination_ThrowsForTooShortDestination(SpanScalarDestinationDelegate<T, T, T> tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, y, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(SpanScalarDestinationFunctionsToTest))]
+        public void SpanScalarDestination_ThrowsForOverlapppingInputWithOutputs(SpanScalarDestinationDelegate<T, T, T> tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            T[] array = new T[10];
+            T y = NextRandom();
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), y, array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), y, array.AsSpan(2, 2)));
+        }
+        #endregion
+
+        #region Shifting/Rotating
+        public static IEnumerable<object[]> ShiftRotateDestinationFunctionsToTest()
+        {
+            yield return new object[] { new SpanScalarDestinationDelegate<T, int, T>(TensorPrimitives.ShiftLeft), new Func<T, int, T>((x, n) => x << n) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, int, T>(TensorPrimitives.ShiftRightArithmetic), new Func<T, int, T>((x, n) => x >> n) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, int, T>(TensorPrimitives.ShiftRightLogical), new Func<T, int, T>((x, n) => x >>> n) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, int, T>(TensorPrimitives.RotateLeft), new Func<T, int, T>(T.RotateLeft) };
+            yield return new object[] { new SpanScalarDestinationDelegate<T, int, T>(TensorPrimitives.RotateRight), new Func<T, int, T>(T.RotateRight) };
+        }
+
+        [Theory]
+        [MemberData(nameof(ShiftRotateDestinationFunctionsToTest))]
+        public void ShiftRotateDestination_AllLengths(SpanScalarDestinationDelegate<T, int, T> tensorPrimitivesMethod, Func<T, int, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                int y = Random.Next(0, T.MaxValue.GetByteCount() * 8);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x[i], y), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ShiftRotateDestinationFunctionsToTest))]
+        public void ShiftRotateDestination_InPlace(SpanScalarDestinationDelegate<T, int, T> tensorPrimitivesMethod, Func<T, int, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                int y = Random.Next(0, T.MaxValue.GetByteCount() * 8);
+                T[] xOrig = x.Span.ToArray();
+
+                tensorPrimitivesMethod(x, y, x);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(xOrig[i], y), x[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ShiftRotateDestinationFunctionsToTest))]
+        public void ShiftRotateDestination_ThrowsForTooShortDestination(SpanScalarDestinationDelegate<T, int, T> tensorPrimitivesMethod, Func<T, int, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, default, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ShiftRotateDestinationFunctionsToTest))]
+        public void ShiftRotateDestination_ThrowsForOverlapppingInputWithOutputs(SpanScalarDestinationDelegate<T, int, T> tensorPrimitivesMethod, Func<T, int, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), default, array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(array.AsSpan(1, 2), default, array.AsSpan(2, 2)));
+        }
+        #endregion
+
+        #region CopySign
+        private void RemoveSignedMinValue(Span<T> span)
+        {
+            for (int i = 0; i < span.Length; i++)
+            {
+                while (T.Sign(span[i]) < 0 && span[i] == T.MinValue)
+                {
+                    span[i] = NextRandom();
+                }
+            }
+        }
+
+        [Fact]
+        public void CopySign_AllLengths()
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                RemoveSignedMinValue(x); // CopySign doesn't work with MinValue for signed integers, so remove any MinValue values from the input.
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                TensorPrimitives.CopySign<T>(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(T.CopySign(x[i], y[i]), destination[i]);
+                }
+
+                if (tensorLength > 0)
+                {
+                    TensorPrimitives.CopySign<T>(x, y[0], destination);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(T.CopySign(x[i], y[0]), destination[i]);
+                    }
+                }
+            });
+        }
+
+        [Fact]
+        public void CopySign_InPlace()
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                RemoveSignedMinValue(x); // CopySign doesn't work with MinValue for signed integers, so remove any MinValue values from the input.
+
+                T[] xOrig = x.Span.ToArray();
+
+                TensorPrimitives.CopySign<T>(x, x, x);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(T.CopySign(xOrig[i], xOrig[i]), x[i]);
+                }
+            });
+        }
+
+        [Fact]
+        public void CopySign_ThrowsForMismatchedLengths()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                Assert.Throws<ArgumentException>(() => TensorPrimitives.CopySign<T>(x, y, destination));
+                Assert.Throws<ArgumentException>(() => TensorPrimitives.CopySign<T>(y, x, destination));
+            });
+        }
+
+        [Fact]
+        public void CopySign_ThrowsForTooShortDestination()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.CopySign<T>(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.CopySign<T>(x, y[0], destination));
             });
         }
+
+        [Fact]
+        public void CopySign_ThrowsForOverlapppingInputsWithOutputs()
+        {
+            T[] array = new T[10];
+
+            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.CopySign(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.CopySign(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.CopySign(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(4, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.CopySign(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(6, 2)));
+
+            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.CopySign(array.AsSpan(1, 2), default(T), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.CopySign(array.AsSpan(1, 2), default(T), array.AsSpan(2, 2)));
+        }
+        #endregion
     }
 
     public unsafe abstract class GenericNumberTensorPrimitivesTests<T> : TensorPrimitivesTests<T>
@@ -203,6 +1560,10 @@ public unsafe abstract class GenericNumberTensorPrimitivesTests<T> : TensorPrimi
         protected override void Divide(ReadOnlySpan<T> x, T y, Span<T> destination) => TensorPrimitives.Divide(x, y, destination);
         protected override T Divide(T x, T y) => x / y;
         protected override T Dot(ReadOnlySpan<T> x, ReadOnlySpan<T> y) => TensorPrimitives.Dot(x, y);
+        protected override int IndexOfMax(ReadOnlySpan<T> x) => TensorPrimitives.IndexOfMax(x);
+        protected override int IndexOfMaxMagnitude(ReadOnlySpan<T> x) => TensorPrimitives.IndexOfMaxMagnitude(x);
+        protected override int IndexOfMin(ReadOnlySpan<T> x) => TensorPrimitives.IndexOfMin(x);
+        protected override int IndexOfMinMagnitude(ReadOnlySpan<T> x) => TensorPrimitives.IndexOfMinMagnitude(x);
         protected override T Max(ReadOnlySpan<T> x) => TensorPrimitives.Max(x);
         protected override void Max(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => TensorPrimitives.Max(x, y, destination);
         protected override T Max(T x, T y) => T.Max(x, y);
@@ -291,5 +1652,76 @@ protected override void AssertEqualTolerance(T expected, T actual, T tolerance)
         protected override T NaN => throw new NotSupportedException();
         protected override IEnumerable<T> GetSpecialValues() => Enumerable.Empty<T>();
         protected override void SetSpecialValues(Span<T> x, Span<T> y) { }
+
+        #region Scalar,Span -> Destination
+        public static IEnumerable<object[]> ScalarSpanDestinationFunctionsToTest()
+        {
+            yield return new object[] { new ScalarSpanDestinationDelegate(TensorPrimitives.Divide), new Func<T, T, T>((x, y) => x / y) };
+            yield return new object[] { new ScalarSpanDestinationDelegate(TensorPrimitives.Subtract), new Func<T, T, T>((x, y) => x - y) };
+        }
+
+        [Theory]
+        [MemberData(nameof(ScalarSpanDestinationFunctionsToTest))]
+        public void ScalarSpanDestination_AllLengths(ScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                T x = NextRandom();
+                using BoundedMemory<T> y = CreateTensor(tensorLength);
+                FillTensor(y.Span, default);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                tensorPrimitivesMethod(x, y, destination);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x, y[i]), destination[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ScalarSpanDestinationFunctionsToTest))]
+        public void ScalarSpanDestination_InPlace(ScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> expectedMethod)
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                T x = NextRandom();
+                using BoundedMemory<T> y = CreateTensor(tensorLength);
+                FillTensor(y.Span, default);
+                T[] yOrig = y.Span.ToArray();
+
+                tensorPrimitivesMethod(x, y.Span, y.Span);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(expectedMethod(x, yOrig[i]), y[i]);
+                }
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ScalarSpanDestinationFunctionsToTest))]
+        public void ScalarSpanDestination_ThrowsForTooShortDestination(ScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                T x = NextRandom();
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(x, y, destination));
+            });
+        }
+
+        [Theory]
+        [MemberData(nameof(ScalarSpanDestinationFunctionsToTest))]
+        public void ScalarSpanDestination_ThrowsForOverlapppingInputsWithOutputs(ScalarSpanDestinationDelegate tensorPrimitivesMethod, Func<T, T, T> _)
+        {
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(default, array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => tensorPrimitivesMethod(default, array.AsSpan(4, 2), array.AsSpan(5, 2)));
+        }
+        #endregion
     }
 }
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 50e3b3dae77d42..85fb2b955cceb9 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.NonGeneric.Single.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.NonGeneric.Single.cs
@@ -1,13 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Buffers;
 using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.InteropServices;
-using Xunit;
 using Xunit.Sdk;
 
+// Tests specific to .NET Standard non-generic APIs
+
 namespace System.Numerics.Tensors.Tests
 {
     public unsafe class NonGenericSingleTensorPrimitivesTests : TensorPrimitivesTests<float>
@@ -35,6 +33,10 @@ public unsafe class NonGenericSingleTensorPrimitivesTests : TensorPrimitivesTest
         protected override void Log(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.Log(x, destination);
         protected override float Log2(float x) => MathF.Log(x, 2);
         protected override void Log2(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.Log2(x, destination);
+        protected override int IndexOfMax(ReadOnlySpan<float> x) => TensorPrimitives.IndexOfMax(x);
+        protected override int IndexOfMaxMagnitude(ReadOnlySpan<float> x) => TensorPrimitives.IndexOfMaxMagnitude(x);
+        protected override int IndexOfMin(ReadOnlySpan<float> x) => TensorPrimitives.IndexOfMin(x);
+        protected override int IndexOfMinMagnitude(ReadOnlySpan<float> x) => TensorPrimitives.IndexOfMinMagnitude(x);
         protected override float Max(ReadOnlySpan<float> x) => TensorPrimitives.Max(x);
         protected override void Max(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) => TensorPrimitives.Max(x, y, destination);
         protected override float Max(float x, float y) => MathF.Max(x, y);
@@ -174,203 +176,5 @@ protected override void SetSpecialValues(Span<float> x, Span<float> y)
         }
 
         private static unsafe float UInt32ToSingle(uint i) => *(float*)&i;
-
-        // TODO: Move these IndexOf tests to the base class once generic versions are implemented.
-        #region IndexOfMax
-        [Fact]
-        public void IndexOfMax_ReturnsNegative1OnEmpty()
-        {
-            Assert.Equal(-1, TensorPrimitives.IndexOfMax(ReadOnlySpan<float>.Empty));
-        }
-
-        [Fact]
-        public void IndexOfMax()
-        {
-            Assert.All(Helpers.TensorLengths, tensorLength =>
-            {
-                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
-                {
-                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                    x[expected] = Enumerable.Max(MemoryMarshal.ToEnumerable<float>(x.Memory)) + 1;
-                    Assert.Equal(expected, TensorPrimitives.IndexOfMax(x));
-                }
-            });
-        }
-
-        [Fact]
-        public void IndexOfMax_FirstNaNReturned()
-        {
-            Assert.All(Helpers.TensorLengths, tensorLength =>
-            {
-                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
-                {
-                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                    x[expected] = float.NaN;
-                    x[tensorLength - 1] = float.NaN;
-                    Assert.Equal(expected, TensorPrimitives.IndexOfMax(x));
-                }
-            });
-        }
-
-        [Fact]
-        public void IndexOfMax_Negative0LesserThanPositive0()
-        {
-            Assert.Equal(1, TensorPrimitives.IndexOfMax([-0f, +0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMax([-0f, -0f, -0f, -0f]));
-            Assert.Equal(4, TensorPrimitives.IndexOfMax([-0f, -0f, -0f, -0f, +0f, +0f, +0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMax([+0f, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMax([-1, -0f]));
-            Assert.Equal(2, TensorPrimitives.IndexOfMax([-1, -0f, 1]));
-        }
-        #endregion
-
-        #region IndexOfMaxMagnitude
-        [Fact]
-        public void IndexOfMaxMagnitude_ReturnsNegative1OnEmpty()
-        {
-            Assert.Equal(-1, TensorPrimitives.IndexOfMaxMagnitude(ReadOnlySpan<float>.Empty));
-        }
-
-        [Fact]
-        public void IndexOfMaxMagnitude()
-        {
-            Assert.All(Helpers.TensorLengths, tensorLength =>
-            {
-                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
-                {
-                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                    x[expected] = Enumerable.Max(MemoryMarshal.ToEnumerable<float>(x.Memory), Math.Abs) + 1;
-                    Assert.Equal(expected, TensorPrimitives.IndexOfMaxMagnitude(x));
-                }
-            });
-        }
-
-        [Fact]
-        public void IndexOfMaxMagnitude_FirstNaNReturned()
-        {
-            Assert.All(Helpers.TensorLengths, tensorLength =>
-            {
-                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
-                {
-                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                    x[expected] = float.NaN;
-                    x[tensorLength - 1] = float.NaN;
-                    Assert.Equal(expected, TensorPrimitives.IndexOfMaxMagnitude(x));
-                }
-            });
-        }
-
-        [Fact]
-        public void IndexOfMaxMagnitude_Negative0LesserThanPositive0()
-        {
-            Assert.Equal(0, TensorPrimitives.IndexOfMaxMagnitude([-0f, -0f, -0f, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMaxMagnitude([-0f, +0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMaxMagnitude([-0f, +0f, +0f, +0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMaxMagnitude([+0f, -0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMaxMagnitude([-1, -0f]));
-            Assert.Equal(2, TensorPrimitives.IndexOfMaxMagnitude([-1, -0f, 1]));
-        }
-        #endregion
-
-        #region IndexOfMin
-        [Fact]
-        public void IndexOfMin_ReturnsNegative1OnEmpty()
-        {
-            Assert.Equal(-1, TensorPrimitives.IndexOfMin(ReadOnlySpan<float>.Empty));
-        }
-
-        [Fact]
-        public void IndexOfMin()
-        {
-            Assert.All(Helpers.TensorLengths, tensorLength =>
-            {
-                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
-                {
-                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                    x[expected] = Enumerable.Min(MemoryMarshal.ToEnumerable<float>(x.Memory)) - 1;
-                    Assert.Equal(expected, TensorPrimitives.IndexOfMin(x));
-                }
-            });
-        }
-
-        [Fact]
-        public void IndexOfMin_FirstNaNReturned()
-        {
-            Assert.All(Helpers.TensorLengths, tensorLength =>
-            {
-                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
-                {
-                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                    x[expected] = float.NaN;
-                    x[tensorLength - 1] = float.NaN;
-                    Assert.Equal(expected, TensorPrimitives.IndexOfMin(x));
-                }
-            });
-        }
-
-        [Fact]
-        public void IndexOfMin_Negative0LesserThanPositive0()
-        {
-            Assert.Equal(0, TensorPrimitives.IndexOfMin([-0f, +0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMin([+0f, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMin([+0f, -0f, -0f, -0f, -0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMin([-1, -0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMin([-1, -0f, 1]));
-        }
-        #endregion
-
-        #region IndexOfMinMagnitude
-        [Fact]
-        public void IndexOfMinMagnitude_ReturnsNegative1OnEmpty()
-        {
-            Assert.Equal(-1, TensorPrimitives.IndexOfMinMagnitude(ReadOnlySpan<float>.Empty));
-        }
-
-        [Fact]
-        public void IndexOfMinMagnitude()
-        {
-            Assert.All(Helpers.TensorLengths, tensorLength =>
-            {
-                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
-                {
-                    using BoundedMemory<float> x = CreateTensor(tensorLength);
-                    for (int i = 0; i < x.Length; i++)
-                    {
-                        x[i] = i % 2 == 0 ? 42 : -42;
-                    }
-
-                    x[expected] = -41;
-
-                    Assert.Equal(expected, TensorPrimitives.IndexOfMinMagnitude(x));
-                }
-            });
-        }
-
-        [Fact]
-        public void IndexOfMinMagnitude_FirstNaNReturned()
-        {
-            Assert.All(Helpers.TensorLengths, tensorLength =>
-            {
-                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
-                {
-                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                    x[expected] = float.NaN;
-                    x[tensorLength - 1] = float.NaN;
-                    Assert.Equal(expected, TensorPrimitives.IndexOfMinMagnitude(x));
-                }
-            });
-        }
-
-        [Fact]
-        public void IndexOfMinMagnitude_Negative0LesserThanPositive0()
-        {
-            Assert.Equal(0, TensorPrimitives.IndexOfMinMagnitude([-0f, -0f, -0f, -0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMinMagnitude([-0f, +0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([+0f, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([+0f, -0f, -0f, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([-1, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([-1, -0f, 1]));
-        }
-        #endregion
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
index 8cc159b5b3b14c..8a9f9ff6b4de29 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
@@ -7,6 +7,8 @@
 using System.Runtime.InteropServices;
 using Xunit;
 
+// Shared helpers and Facts/Theories used by both generic methods on .NET Core and non-generic methods on .NET Framework
+
 namespace System.Numerics.Tensors.Tests
 {
     public abstract class TensorPrimitivesTests<T> where T : unmanaged, IEquatable<T>
@@ -25,6 +27,10 @@ public abstract class TensorPrimitivesTests<T> where T : unmanaged, IEquatable<T
         protected abstract void Divide(ReadOnlySpan<T> x, T y, Span<T> destination);
         protected abstract T Dot(ReadOnlySpan<T> x, ReadOnlySpan<T> y);
         protected abstract void Exp(ReadOnlySpan<T> x, Span<T> destination);
+        protected abstract int IndexOfMax(ReadOnlySpan<T> x);
+        protected abstract int IndexOfMaxMagnitude(ReadOnlySpan<T> x);
+        protected abstract int IndexOfMin(ReadOnlySpan<T> x);
+        protected abstract int IndexOfMinMagnitude(ReadOnlySpan<T> x);
         protected abstract void Log(ReadOnlySpan<T> x, Span<T> destination);
         protected abstract void Log2(ReadOnlySpan<T> x, Span<T> destination);
         protected abstract T Max(ReadOnlySpan<T> x);
@@ -84,6 +90,16 @@ public abstract class TensorPrimitivesTests<T> where T : unmanaged, IEquatable<T
         #endregion
 
         #region Test Utilities
+
+        public delegate void SpanDestinationDelegate(ReadOnlySpan<T> x, Span<T> destination);
+        public delegate void SpanSpanDestinationDelegate(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination);
+        public delegate void SpanScalarDestinationDelegate<T1, T2, T3>(ReadOnlySpan<T1> x, T2 y, Span<T3> destination);
+        public delegate void ScalarSpanDestinationDelegate(T x, ReadOnlySpan<T> y, Span<T> destination);
+        public delegate void SpanSpanSpanDestinationDelegate(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> z, Span<T> destination);
+        public delegate void SpanSpanScalarDestinationDelegate(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T z, Span<T> destination);
+        public delegate void SpanScalarSpanDestinationDelegate(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> z, Span<T> destination);
+        public delegate void SpanDestinationDestinationDelegate(ReadOnlySpan<T> x, Span<T> destination1, Span<T> destination2);
+
         protected virtual bool IsFloatingPoint => typeof(T) == typeof(float) || typeof(T) == typeof(double);
 
         protected abstract T ConvertFromSingle(float f);
@@ -236,15 +252,6 @@ public void Add_TwoTensors()
                 {
                     AssertEqualTolerance(Add(x[i], y[i]), destination[i]);
                 }
-
-                T[] xOrig = x.Span.ToArray();
-
-                // Validate that the destination can be the same as an input.
-                Add(x, x, x);
-                for (int i = 0; i < tensorLength; i++)
-                {
-                    AssertEqualTolerance(Add(xOrig[i], xOrig[i]), x[i]);
-                }
             });
         }
 
@@ -1047,6 +1054,265 @@ public void Exp_ThrowsForOverlapppingInputsWithOutputs()
         }
         #endregion
 
+        #region IndexOfMax
+        [Fact]
+        public void IndexOfMax_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, IndexOfMax(ReadOnlySpan<T>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMax_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 = IndexOfMax(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 IndexOfMax_FirstNaNReturned()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = ConvertFromSingle(float.NaN);
+                    x[tensorLength - 1] = ConvertFromSingle(float.NaN);
+                    Assert.Equal(expected, IndexOfMax(x.Span));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMax_Negative0LesserThanPositive0()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.Equal(1, IndexOfMax([ConvertFromSingle(-0f), ConvertFromSingle(+0f)]));
+            Assert.Equal(0, IndexOfMax([ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(4, IndexOfMax([ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(+0f), ConvertFromSingle(+0f), ConvertFromSingle(+0f)]));
+            Assert.Equal(0, IndexOfMax([ConvertFromSingle(+0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(1, IndexOfMax([ConvertFromSingle(-1),  ConvertFromSingle(-0f)]));
+            Assert.Equal(2, IndexOfMax([ConvertFromSingle(-1),  ConvertFromSingle(-0f), ConvertFromSingle(1f)]));
+        }
+        #endregion
+
+        #region IndexOfMaxMagnitude
+        [Fact]
+        public void IndexOfMaxMagnitude_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, IndexOfMaxMagnitude(ReadOnlySpan<T>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMaxMagnitude_AllLengths()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateTensor(tensorLength);
+                    FillTensor(x, MinValue);
+
+                    T max = x[0];
+                    for (int i = 0; i < x.Length; i++)
+                    {
+                        int compared = Comparer<T>.Default.Compare(Abs(x[i]), Abs(max));
+                        if (compared > 0 || (compared == 0 && EqualityComparer<T>.Default.Equals(x[i], max)))
+                        {
+                            max = x[i];
+                        }
+                    }
+                    x[expected] = max;
+
+                    int actual = IndexOfMaxMagnitude(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(Abs(x[expected]), Abs(x[actual]));
+                        }
+                        else
+                        {
+                            Assert.Equal(Abs(x[expected]), Abs(x[actual]));
+                        }
+                    }
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxMagnitude_FirstNaNReturned()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = ConvertFromSingle(float.NaN);
+                    x[tensorLength - 1] = ConvertFromSingle(float.NaN);
+                    Assert.Equal(expected, IndexOfMaxMagnitude(x));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxMagnitude_Negative0LesserThanPositive0()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.Equal(0, IndexOfMaxMagnitude([ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(1, IndexOfMaxMagnitude([ConvertFromSingle(-0f), ConvertFromSingle(+0f)]));
+            Assert.Equal(1, IndexOfMaxMagnitude([ConvertFromSingle(-0f), ConvertFromSingle(+0f), ConvertFromSingle(+0f), ConvertFromSingle(+0f)]));
+            Assert.Equal(0, IndexOfMaxMagnitude([ConvertFromSingle(+0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(0, IndexOfMaxMagnitude([ConvertFromSingle(-1),  ConvertFromSingle(-0f)]));
+            Assert.Equal(2, IndexOfMaxMagnitude([ConvertFromSingle(-1),  ConvertFromSingle(-0f), ConvertFromSingle(1f)]));
+        }
+        #endregion
+
+        #region IndexOfMin
+        [Fact]
+        public void IndexOfMin_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, IndexOfMin(ReadOnlySpan<T>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMin_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 = IndexOfMin(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 IndexOfMin_FirstNaNReturned()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = ConvertFromSingle(float.NaN);
+                    x[tensorLength - 1] = ConvertFromSingle(float.NaN);
+                    Assert.Equal(expected, IndexOfMin(x));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMin_Negative0LesserThanPositive0()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.Equal(0, IndexOfMin([ConvertFromSingle(-0f), ConvertFromSingle(+0f)]));
+            Assert.Equal(1, IndexOfMin([ConvertFromSingle(+0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(1, IndexOfMin([ConvertFromSingle(+0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(0, IndexOfMin([ConvertFromSingle(-1),  ConvertFromSingle(-0f)]));
+            Assert.Equal(0, IndexOfMin([ConvertFromSingle(-1),  ConvertFromSingle(-0f), ConvertFromSingle(1f)]));
+        }
+        #endregion
+
+        #region IndexOfMinMagnitude
+        [Fact]
+        public void IndexOfMinMagnitude_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, IndexOfMinMagnitude(ReadOnlySpan<T>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMinMagnitude_AllLengths()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateTensor(tensorLength);
+                    FillTensor(x, MinValue);
+
+                    T min = x[0];
+                    for (int i = 0; i < x.Length; i++)
+                    {
+                        int compared = Comparer<T>.Default.Compare(Abs(x[i]), Abs(min));
+                        if (compared < 0 || (compared == 0 && Comparer<T>.Default.Compare(x[i], min) < 0))
+                        {
+                            min = x[i];
+                        }
+                    }
+
+                    x[expected] = min;
+                    int actual = IndexOfMinMagnitude(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(Abs(x[expected]), Abs(x[actual]));
+                        }
+                        else
+                        {
+                            Assert.Equal(Abs(x[expected]), Abs(x[actual]));
+                        }
+                    }
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinMagnitude_FirstNaNReturned()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = ConvertFromSingle(float.NaN);
+                    x[tensorLength - 1] = ConvertFromSingle(float.NaN);
+                    Assert.Equal(expected, IndexOfMinMagnitude(x));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinMagnitude_Negative0LesserThanPositive0()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.Equal(0, IndexOfMinMagnitude([ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(0, IndexOfMinMagnitude([ConvertFromSingle(-0f), ConvertFromSingle(+0f)]));
+            Assert.Equal(1, IndexOfMinMagnitude([ConvertFromSingle(+0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(1, IndexOfMinMagnitude([ConvertFromSingle(+0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(1, IndexOfMinMagnitude([ConvertFromSingle(-1),  ConvertFromSingle(-0f)]));
+            Assert.Equal(1, IndexOfMinMagnitude([ConvertFromSingle(-1),  ConvertFromSingle(-0f), ConvertFromSingle(1f)]));
+        }
+        #endregion
+
         #region Log
         [Fact]
         public void Log_AllValues()