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 031ba109ba6b57..de78d145524b0b 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
@@ -35,6 +35,9 @@ public static void BitwiseOr<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<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 ConvertChecked<TFrom, TTo>(System.ReadOnlySpan<TFrom> source, System.Span<TTo> destination) where TFrom : System.Numerics.INumberBase<TFrom> where TTo : System.Numerics.INumberBase<TTo> { }
+        public static void ConvertSaturating<TFrom, TTo>(System.ReadOnlySpan<TFrom> source, System.Span<TTo> destination) where TFrom : System.Numerics.INumberBase<TFrom> where TTo : System.Numerics.INumberBase<TTo> { }
+        public static void ConvertTruncating<TFrom, TTo>(System.ReadOnlySpan<TFrom> source, System.Span<TTo> destination) where TFrom : System.Numerics.INumberBase<TFrom> where TTo : System.Numerics.INumberBase<TTo> { }
         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> { }
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 1148639d48be02..32723d2b3c3c5e 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
@@ -43,7 +43,7 @@ public static unsafe partial class TensorPrimitives
     {
         private static void InvokeSpanIntoSpan<TSingleUnaryOperator>(
             ReadOnlySpan<float> x, Span<float> destination)
-            where TSingleUnaryOperator : struct, IUnaryOperator<float> =>
+            where TSingleUnaryOperator : struct, IUnaryOperator<float, float> =>
             InvokeSpanIntoSpan<float, TSingleUnaryOperator>(x, destination);
 
         private static void InvokeSpanSpanIntoSpan<TSingleBinaryOperator>(
@@ -58,7 +58,7 @@ private static void InvokeSpanScalarIntoSpan<TSingleBinaryOperator>(
 
         private static unsafe void InvokeSpanScalarIntoSpan<TSingleTransformOperator, TSingleBinaryOperator>(
             ReadOnlySpan<float> x, float y, Span<float> destination)
-            where TSingleTransformOperator : struct, IUnaryOperator<float>
+            where TSingleTransformOperator : struct, IUnaryOperator<float, float>
             where TSingleBinaryOperator : struct, IBinaryOperator<float> =>
             InvokeSpanScalarIntoSpan<float, TSingleTransformOperator, TSingleBinaryOperator>(x, y, destination);
 
@@ -79,7 +79,7 @@ private static void InvokeSpanScalarSpanIntoSpan<TSingleTernaryOperator>(
 
         private static unsafe float Aggregate<TSingleTransformOperator, TSingleAggregationOperator>(
             ReadOnlySpan<float> x)
-            where TSingleTransformOperator : struct, IUnaryOperator<float>
+            where TSingleTransformOperator : struct, IUnaryOperator<float, float>
             where TSingleAggregationOperator : struct, IAggregationOperator<float> =>
             Aggregate<float, TSingleTransformOperator, TSingleAggregationOperator>(x);
 
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 4009257b22d36f..0562d74cc9dc49 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,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Runtime.CompilerServices;
+
 namespace System.Numerics.Tensors
 {
     /// <summary>Performs primitive tensor operations over spans of memory.</summary>
@@ -488,6 +490,249 @@ public static void Ceiling<T>(ReadOnlySpan<T> x, Span<T> destination)
             where T : IFloatingPoint<T> =>
             InvokeSpanIntoSpan<T, CeilingOperator<T>>(x, destination);
 
+        /// <summary>
+        /// Copies <paramref name="source"/> to <paramref name="destination"/>, converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
+        /// </summary>
+        /// <param name="source">The source span from which to copy values.</param>
+        /// <param name="destination">The destination span into which the converted values should be written.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = TTo.CreateChecked(<paramref name="source"/>[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void ConvertChecked<TFrom, TTo>(ReadOnlySpan<TFrom> source, Span<TTo> destination)
+            where TFrom : INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            if (!TryConvertUniversal(source, destination))
+            {
+                InvokeSpanIntoSpan<TFrom, TTo, ConvertCheckedFallbackOperator<TFrom, TTo>>(source, destination);
+            }
+        }
+
+        /// <summary>
+        /// Copies <paramref name="source"/> to <paramref name="destination"/>, converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
+        /// </summary>
+        /// <param name="source">The source span from which to copy values.</param>
+        /// <param name="destination">The destination span into which the converted values should be written.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = TTo.CreateSaturating(<paramref name="source"/>[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void ConvertSaturating<TFrom, TTo>(ReadOnlySpan<TFrom> source, Span<TTo> destination)
+            where TFrom : INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            if (!TryConvertUniversal(source, destination))
+            {
+                InvokeSpanIntoSpan<TFrom, TTo, ConvertSaturatingFallbackOperator<TFrom, TTo>>(source, destination);
+            }
+        }
+
+        /// <summary>
+        /// Copies <paramref name="source"/> to <paramref name="destination"/>, converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
+        /// </summary>
+        /// <param name="source">The source span from which to copy values.</param>
+        /// <param name="destination">The destination span into which the converted values should be written.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = TTo.CreateTruncating(<paramref name="source"/>[i])</c>.
+        /// </para>
+        /// </remarks>
+        public static void ConvertTruncating<TFrom, TTo>(ReadOnlySpan<TFrom> source, Span<TTo> destination)
+            where TFrom : INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            if (TryConvertUniversal(source, destination))
+            {
+                return;
+            }
+
+            if (((typeof(TFrom) == typeof(byte) || typeof(TFrom) == typeof(sbyte)) && (typeof(TTo) == typeof(byte) || typeof(TTo) == typeof(sbyte))) ||
+                ((typeof(TFrom) == typeof(ushort) || typeof(TFrom) == typeof(short)) && (typeof(TTo) == typeof(ushort) || typeof(TTo) == typeof(short))) ||
+                ((IsUInt32Like<TFrom>() || IsInt32Like<TFrom>()) && (IsUInt32Like<TTo>() || IsInt32Like<TTo>())) ||
+                ((IsUInt64Like<TFrom>() || IsInt64Like<TFrom>()) && (IsUInt64Like<TTo>() || IsInt64Like<TTo>())))
+            {
+                source.CopyTo(Rename<TTo, TFrom>(destination));
+                return;
+            }
+
+            if (typeof(TFrom) == typeof(float) && IsUInt32Like<TTo>())
+            {
+                InvokeSpanIntoSpan<float, uint, ConvertSingleToUInt32>(Rename<TFrom, float>(source), Rename<TTo, uint>(destination));
+                return;
+            }
+
+            if (typeof(TFrom) == typeof(float) && IsInt32Like<TTo>())
+            {
+                InvokeSpanIntoSpan<float, int, ConvertSingleToInt32>(Rename<TFrom, float>(source), Rename<TTo, int>(destination));
+                return;
+            }
+
+            if (typeof(TFrom) == typeof(double) && IsUInt64Like<TTo>())
+            {
+                InvokeSpanIntoSpan<double, ulong, ConvertDoubleToUInt64>(Rename<TFrom, double>(source), Rename<TTo, ulong>(destination));
+                return;
+            }
+
+            if (typeof(TFrom) == typeof(double) && IsInt64Like<TTo>())
+            {
+                InvokeSpanIntoSpan<double, long, ConvertDoubleToInt64>(Rename<TFrom, double>(source), Rename<TTo, long>(destination));
+                return;
+            }
+
+            if (typeof(TFrom) == typeof(ushort) && typeof(TTo) == typeof(byte))
+            {
+                InvokeSpanIntoSpan_2to1<ushort, byte, NarrowUInt16ToByteOperator>(Rename<TFrom, ushort>(source), Rename<TTo, byte>(destination));
+                return;
+            }
+
+            if (typeof(TFrom) == typeof(short) && typeof(TTo) == typeof(sbyte))
+            {
+                InvokeSpanIntoSpan_2to1<short, sbyte, NarrowInt16ToSByteOperator>(Rename<TFrom, short>(source), Rename<TTo, sbyte>(destination));
+                return;
+            }
+
+            if (IsUInt32Like<TFrom>() && typeof(TTo) == typeof(ushort))
+            {
+                InvokeSpanIntoSpan_2to1<uint, ushort, NarrowUInt32ToUInt16Operator>(Rename<TFrom, uint>(source), Rename<TTo, ushort>(destination));
+                return;
+            }
+
+            if (IsInt32Like<TFrom>() && typeof(TTo) == typeof(short))
+            {
+                InvokeSpanIntoSpan_2to1<int, short, NarrowInt32ToInt16Operator>(Rename<TFrom, int>(source), Rename<TTo, short>(destination));
+                return;
+            }
+
+            if (IsUInt64Like<TFrom>() && IsUInt32Like<TTo>())
+            {
+                InvokeSpanIntoSpan_2to1<ulong, uint, NarrowUInt64ToUInt32Operator>(Rename<TFrom, ulong>(source), Rename<TTo, uint>(destination));
+                return;
+            }
+
+            if (IsInt64Like<TFrom>() && IsInt32Like<TTo>())
+            {
+                InvokeSpanIntoSpan_2to1<long, int, NarrowInt64ToInt32Operator>(Rename<TFrom, long>(source), Rename<TTo, int>(destination));
+                return;
+            }
+
+            InvokeSpanIntoSpan<TFrom, TTo, ConvertTruncatingFallbackOperator<TFrom, TTo>>(source, destination);
+        }
+
+        /// <summary>Performs conversions that are the same regardless of checked, truncating, or saturation.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)] // at most one of the branches will be kept
+        private static bool TryConvertUniversal<TFrom, TTo>(ReadOnlySpan<TFrom> source, Span<TTo> destination)
+            where TFrom : INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            if (typeof(TFrom) == typeof(TTo))
+            {
+                if (source.Length > destination.Length)
+                {
+                    ThrowHelper.ThrowArgument_DestinationTooShort();
+                }
+
+                ValidateInputOutputSpanNonOverlapping(source, Rename<TTo, TFrom>(destination));
+
+                source.CopyTo(Rename<TTo, TFrom>(destination));
+                return true;
+            }
+
+            if (IsInt32Like<TFrom>() && typeof(TTo) == typeof(float))
+            {
+                InvokeSpanIntoSpan<int, float, ConvertInt32ToSingle>(Rename<TFrom, int>(source), Rename<TTo, float>(destination));
+                return true;
+            }
+
+            if (IsUInt32Like<TFrom>() && typeof(TTo) == typeof(float))
+            {
+                InvokeSpanIntoSpan<uint, float, ConvertUInt32ToSingle>(Rename<TFrom, uint>(source), Rename<TTo, float>(destination));
+                return true;
+            }
+
+            if (IsInt64Like<TFrom>() && typeof(TTo) == typeof(double))
+            {
+                InvokeSpanIntoSpan<long, double, ConvertInt64ToDouble>(Rename<TFrom, long>(source), Rename<TTo, double>(destination));
+                return true;
+            }
+
+            if (IsUInt64Like<TFrom>() && typeof(TTo) == typeof(double))
+            {
+                InvokeSpanIntoSpan<ulong, double, ConvertUInt64ToDouble>(Rename<TFrom, ulong>(source), Rename<TTo, double>(destination));
+                return true;
+            }
+
+            if (typeof(TFrom) == typeof(float) && typeof(TTo) == typeof(Half))
+            {
+                ConvertToHalf(Rename<TFrom, float>(source), Rename<TTo, Half>(destination));
+                return true;
+            }
+
+            if (typeof(TFrom) == typeof(Half) && typeof(TTo) == typeof(float))
+            {
+                ConvertToSingle(Rename<TFrom, Half>(source), Rename<TTo, float>(destination));
+                return true;
+            }
+
+            if (typeof(TFrom) == typeof(float) && typeof(TTo) == typeof(double))
+            {
+                InvokeSpanIntoSpan_1to2<float, double, WidenSingleToDoubleOperator>(Rename<TFrom, float>(source), Rename<TTo, double>(destination));
+                return true;
+            }
+
+            if (typeof(TFrom) == typeof(double) && typeof(TTo) == typeof(float))
+            {
+                InvokeSpanIntoSpan_2to1<double, float, NarrowDoubleToSingleOperator>(Rename<TFrom, double>(source), Rename<TTo, float>(destination));
+                return true;
+            }
+
+            if (typeof(TFrom) == typeof(byte) && typeof(TTo) == typeof(ushort))
+            {
+                InvokeSpanIntoSpan_1to2<byte, ushort, WidenByteToUInt16Operator>(Rename<TFrom, byte>(source), Rename<TTo, ushort>(destination));
+                return true;
+            }
+
+            if (typeof(TFrom) == typeof(sbyte) && typeof(TTo) == typeof(short))
+            {
+                InvokeSpanIntoSpan_1to2<sbyte, short, WidenSByteToInt16Operator>(Rename<TFrom, sbyte>(source), Rename<TTo, short>(destination));
+                return true;
+            }
+
+            if (typeof(TFrom) == typeof(ushort) && IsUInt32Like<TTo>())
+            {
+                InvokeSpanIntoSpan_1to2<ushort, uint, WidenUInt16ToUInt32Operator>(Rename<TFrom, ushort>(source), Rename<TTo, uint>(destination));
+                return true;
+            }
+
+            if (typeof(TFrom) == typeof(short) && IsInt32Like<TTo>())
+            {
+                InvokeSpanIntoSpan_1to2<short, int, WidenInt16ToInt32Operator>(Rename<TFrom, short>(source), Rename<TTo, int>(destination));
+                return true;
+            }
+
+            if (IsUInt32Like<TTo>() && IsUInt64Like<TTo>())
+            {
+                InvokeSpanIntoSpan_1to2<uint, ulong, WidenUInt32ToUInt64Operator>(Rename<TFrom, uint>(source), Rename<TTo, ulong>(destination));
+                return true;
+            }
+
+            if (IsInt32Like<TFrom>() && IsInt64Like<TTo>())
+            {
+                InvokeSpanIntoSpan_1to2<int, long, WidenInt32ToInt64Operator>(Rename<TFrom, int>(source), Rename<TTo, long>(destination));
+                return true;
+            }
+
+            return false;
+        }
+
         /// <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 span.</param>
@@ -963,15 +1208,14 @@ public static void Ieee754Remainder<T>(T x, ReadOnlySpan<T> y, Span<T> destinati
         public static void ILogB<T>(ReadOnlySpan<T> x, Span<int> destination)
             where T : IFloatingPointIeee754<T>
         {
-            if (x.Length > destination.Length)
+            if (typeof(T) == typeof(double))
             {
-                ThrowHelper.ThrowArgument_DestinationTooShort();
+                // Special-case double as the only vectorizable floating-point type whose size != sizeof(int).
+                InvokeSpanIntoSpan_2to1<double, int, ILogBDoubleOperator>(Rename<T, double>(x), destination);
             }
-
-            // TODO: Vectorize
-            for (int i = 0; i < x.Length; i++)
+            else
             {
-                destination[i] = T.ILogB(x[i]);
+                InvokeSpanIntoSpan<T, int, ILogBOperator<T>>(x, 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 bb9285b59d1e2e..fec346b381913f 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
@@ -800,7 +800,7 @@ private static T CosineSimilarityCore<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y) w
         /// </typeparam>
         private static T Aggregate<T, TTransformOperator, TAggregationOperator>(
             ReadOnlySpan<T> x)
-            where TTransformOperator : struct, IUnaryOperator<T>
+            where TTransformOperator : struct, IUnaryOperator<T, T>
             where TAggregationOperator : struct, IAggregationOperator<T>
         {
             // Since every branch has a cost and since that cost is
@@ -2242,7 +2242,7 @@ static T Vectorized512(ref T xRef, ref T yRef, nuint remainder)
                     case 3:
                     {
                         Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 3)));
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 3)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 2;
                     }
@@ -3021,32 +3021,49 @@ 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>
+        /// <typeparam name="T">The element input type.</typeparam>
         /// <typeparam name="TUnaryOperator">Specifies the operation to perform on each element loaded from <paramref name="x"/>.</typeparam>
         private static void InvokeSpanIntoSpan<T, TUnaryOperator>(
             ReadOnlySpan<T> x, Span<T> destination)
-            where TUnaryOperator : struct, IUnaryOperator<T>
+            where TUnaryOperator : struct, IUnaryOperator<T, T> =>
+            InvokeSpanIntoSpan<T, T, TUnaryOperator>(x, destination);
+
+        /// <summary>Performs an element-wise operation on <paramref name="x"/> and writes the results to <paramref name="destination"/>.</summary>
+        /// <typeparam name="TInput">The element input type.</typeparam>
+        /// <typeparam name="TOutput">The element output type. Must be the same size as TInput if TInput and TOutput both support vectorization.</typeparam>
+        /// <typeparam name="TUnaryOperator">Specifies the operation to perform on each element loaded from <paramref name="x"/>.</typeparam>
+        /// <remarks>
+        /// This supports vectorizing the operation if <typeparamref name="TInput"/> and <typeparamref name="TOutput"/> are the same size.
+        /// Otherwise, it'll fall back to scalar operations.
+        /// </remarks>
+        private static void InvokeSpanIntoSpan<TInput, TOutput, TUnaryOperator>(
+            ReadOnlySpan<TInput> x, Span<TOutput> destination)
+            where TUnaryOperator : struct, IUnaryOperator<TInput, TOutput>
         {
             if (x.Length > destination.Length)
             {
                 ThrowHelper.ThrowArgument_DestinationTooShort();
             }
 
-            ValidateInputOutputSpanNonOverlapping(x, destination);
+            if (typeof(TInput) == typeof(TOutput))
+            {
+                // This ignores the unsafe case where a developer passes in overlapping spans for distinct types.
+                ValidateInputOutputSpanNonOverlapping(x, Rename<TOutput, TInput>(destination));
+            }
 
             // Since every branch has a cost and since that cost is
             // essentially lost for larger inputs, we do branches
             // in a way that allows us to have the minimum possible
             // for small sizes
 
-            ref T xRef = ref MemoryMarshal.GetReference(x);
-            ref T dRef = ref MemoryMarshal.GetReference(destination);
+            ref TInput xRef = ref MemoryMarshal.GetReference(x);
+            ref TOutput dRef = ref MemoryMarshal.GetReference(destination);
 
             nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TUnaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
+            if (Vector512.IsHardwareAccelerated && Vector512<TInput>.IsSupported && Vector512<TOutput>.IsSupported && TUnaryOperator.Vectorizable && Unsafe.SizeOf<TInput>() >= 4 && Unsafe.SizeOf<TInput>() == Unsafe.SizeOf<TOutput>())
             {
-                if (remainder >= (uint)Vector512<T>.Count)
+                if (remainder >= (uint)Vector512<TInput>.Count)
                 {
                     Vectorized512(ref xRef, ref dRef, remainder);
                 }
@@ -3062,9 +3079,9 @@ private static void InvokeSpanIntoSpan<T, TUnaryOperator>(
                 return;
             }
 
-            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TUnaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
+            if (Vector256.IsHardwareAccelerated && Vector256<TInput>.IsSupported && Vector256<TOutput>.IsSupported && TUnaryOperator.Vectorizable && Unsafe.SizeOf<TInput>() >= 4 && Unsafe.SizeOf<TInput>() == Unsafe.SizeOf<TOutput>())
             {
-                if (remainder >= (uint)Vector256<T>.Count)
+                if (remainder >= (uint)Vector256<TInput>.Count)
                 {
                     Vectorized256(ref xRef, ref dRef, remainder);
                 }
@@ -3080,9 +3097,9 @@ private static void InvokeSpanIntoSpan<T, TUnaryOperator>(
                 return;
             }
 
-            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && TUnaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
+            if (Vector128.IsHardwareAccelerated && Vector128<TInput>.IsSupported && Vector128<TOutput>.IsSupported && TUnaryOperator.Vectorizable && Unsafe.SizeOf<TInput>() >= 4 && Unsafe.SizeOf<TInput>() == Unsafe.SizeOf<TOutput>())
             {
-                if (remainder >= (uint)Vector128<T>.Count)
+                if (remainder >= (uint)Vector128<TInput>.Count)
                 {
                     Vectorized128(ref xRef, ref dRef, remainder);
                 }
@@ -3104,7 +3121,7 @@ private static void InvokeSpanIntoSpan<T, TUnaryOperator>(
             SoftwareFallback(ref xRef, ref dRef, remainder);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void SoftwareFallback(ref T xRef, ref T dRef, nuint length)
+            static void SoftwareFallback(ref TInput xRef, ref TOutput dRef, nuint length)
             {
                 for (nuint i = 0; i < length; i++)
                 {
@@ -3112,31 +3129,31 @@ static void SoftwareFallback(ref T xRef, ref T dRef, nuint length)
                 }
             }
 
-            static void Vectorized128(ref T xRef, ref T dRef, nuint remainder)
+            static void Vectorized128(ref TInput xRef, ref TOutput dRef, nuint remainder)
             {
-                ref T dRefBeg = ref dRef;
+                ref TOutput dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector128<T> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
-                Vector128<T> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count));
+                Vector128<TOutput> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                Vector128<TOutput> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<TInput>.Count));
 
-                if (remainder > (uint)(Vector128<T>.Count * 8))
+                if (remainder > (uint)(Vector128<TInput>.Count * 8))
                 {
                     // Pinning is cheap and will be short lived for small inputs and unlikely to be impactful
                     // for large inputs (> 85KB) which are on the LOH and unlikely to be compacted.
 
-                    fixed (T* px = &xRef)
-                    fixed (T* pd = &dRef)
+                    fixed (TInput* px = &xRef)
+                    fixed (TOutput* pd = &dRef)
                     {
-                        T* xPtr = px;
-                        T* dPtr = pd;
+                        TInput* xPtr = px;
+                        TOutput* dPtr = pd;
 
                         // We need to the ensure the underlying data can be aligned and only align
                         // it if it can. It is possible we have an unaligned ref, in which case we
                         // can never achieve the required SIMD alignment.
 
-                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(TInput)) == 0;
 
                         if (canAlign)
                         {
@@ -3146,96 +3163,96 @@ static void Vectorized128(ref T xRef, ref T dRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)sizeof(Vector128<T>) - ((nuint)dPtr % (uint)sizeof(Vector128<T>))) / (uint)sizeof(T);
+                            nuint misalignment = ((uint)sizeof(Vector128<TInput>) - ((nuint)dPtr % (uint)sizeof(Vector128<TInput>))) / (uint)sizeof(TInput);
 
                             xPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector128<T>)) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector128<TInput>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector128<T> vector1;
-                        Vector128<T> vector2;
-                        Vector128<T> vector3;
-                        Vector128<T> vector4;
+                        Vector128<TOutput> vector1;
+                        Vector128<TOutput> vector2;
+                        Vector128<TOutput> vector3;
+                        Vector128<TOutput> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(TInput))) && canAlign)
                         {
                             // This loop stores the data non-temporally, which benefits us when there
                             // is a large amount of data involved as it avoids polluting the cache.
 
-                            while (remainder >= (uint)(Vector128<T>.Count * 8))
+                            while (remainder >= (uint)(Vector128<TInput>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)));
+                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 0)));
+                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 1)));
+                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 2)));
+                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 3)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<T>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<T>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<T>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<T>.Count * 3));
+                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<TOutput>.Count * 0));
+                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<TOutput>.Count * 1));
+                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<TOutput>.Count * 2));
+                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<TOutput>.Count * 3));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)));
+                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 4)));
+                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 5)));
+                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 6)));
+                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 7)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<T>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<T>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<T>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<T>.Count * 7));
+                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<TOutput>.Count * 4));
+                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<TOutput>.Count * 5));
+                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<TOutput>.Count * 6));
+                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<TOutput>.Count * 7));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<T>.Count * 8);
-                                dPtr += (uint)(Vector128<T>.Count * 8);
+                                xPtr += (uint)(Vector128<TInput>.Count * 8);
+                                dPtr += (uint)(Vector128<TOutput>.Count * 8);
 
-                                remainder -= (uint)(Vector128<T>.Count * 8);
+                                remainder -= (uint)(Vector128<TInput>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector128<T>.Count * 8))
+                            while (remainder >= (uint)(Vector128<TInput>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)));
+                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 0)));
+                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 1)));
+                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 2)));
+                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 3)));
 
-                                vector1.Store(dPtr + (uint)(Vector128<T>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector128<T>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector128<T>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector128<T>.Count * 3));
+                                vector1.Store(dPtr + (uint)(Vector128<TOutput>.Count * 0));
+                                vector2.Store(dPtr + (uint)(Vector128<TOutput>.Count * 1));
+                                vector3.Store(dPtr + (uint)(Vector128<TOutput>.Count * 2));
+                                vector4.Store(dPtr + (uint)(Vector128<TOutput>.Count * 3));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)));
+                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 4)));
+                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 5)));
+                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 6)));
+                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<TInput>.Count * 7)));
 
-                                vector1.Store(dPtr + (uint)(Vector128<T>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector128<T>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector128<T>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector128<T>.Count * 7));
+                                vector1.Store(dPtr + (uint)(Vector128<TOutput>.Count * 4));
+                                vector2.Store(dPtr + (uint)(Vector128<TOutput>.Count * 5));
+                                vector3.Store(dPtr + (uint)(Vector128<TOutput>.Count * 6));
+                                vector4.Store(dPtr + (uint)(Vector128<TOutput>.Count * 7));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<T>.Count * 8);
-                                dPtr += (uint)(Vector128<T>.Count * 8);
+                                xPtr += (uint)(Vector128<TInput>.Count * 8);
+                                dPtr += (uint)(Vector128<TOutput>.Count * 8);
 
-                                remainder -= (uint)(Vector128<T>.Count * 8);
+                                remainder -= (uint)(Vector128<TInput>.Count * 8);
                             }
                         }
 
@@ -3254,63 +3271,63 @@ static void Vectorized128(ref T xRef, ref T dRef, nuint remainder)
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector128<T>.Count - 1)) & (nuint)(-Vector128<T>.Count);
+                remainder = (remainder + (uint)(Vector128<TInput>.Count - 1)) & (nuint)(-Vector128<TInput>.Count);
 
-                switch (remainder / (uint)Vector128<T>.Count)
+                switch (remainder / (uint)Vector128<TInput>.Count)
                 {
                     case 8:
                     {
-                        Vector128<T> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 8));
+                        Vector128<TOutput> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<TInput>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<TOutput>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector128<T> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 7));
+                        Vector128<TOutput> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<TInput>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<TOutput>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector128<T> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 6));
+                        Vector128<TOutput> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<TInput>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<TOutput>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector128<T> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 5));
+                        Vector128<TOutput> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<TInput>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<TOutput>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector128<T> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 4));
+                        Vector128<TOutput> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<TInput>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<TOutput>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector128<T> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 3));
+                        Vector128<TOutput> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<TInput>.Count * 3)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<TOutput>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector128<T> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 2));
+                        Vector128<TOutput> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<TInput>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<TOutput>.Count * 2));
                         goto case 1;
                     }
 
                     case 1:
                     {
                         // Store the last block, which includes any elements that wouldn't fill a full vector
-                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector128<T>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector128<TInput>.Count);
                         goto case 0;
                     }
 
@@ -3323,31 +3340,31 @@ static void Vectorized128(ref T xRef, ref T dRef, nuint remainder)
                 }
             }
 
-            static void Vectorized256(ref T xRef, ref T dRef, nuint remainder)
+            static void Vectorized256(ref TInput xRef, ref TOutput dRef, nuint remainder)
             {
-                ref T dRefBeg = ref dRef;
+                ref TOutput dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector256<T> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
-                Vector256<T> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count));
+                Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
+                Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count));
 
-                if (remainder > (uint)(Vector256<T>.Count * 8))
+                if (remainder > (uint)(Vector256<TInput>.Count * 8))
                 {
                     // Pinning is cheap and will be short lived for small inputs and unlikely to be impactful
                     // for large inputs (> 85KB) which are on the LOH and unlikely to be compacted.
 
-                    fixed (T* px = &xRef)
-                    fixed (T* pd = &dRef)
+                    fixed (TInput* px = &xRef)
+                    fixed (TOutput* pd = &dRef)
                     {
-                        T* xPtr = px;
-                        T* dPtr = pd;
+                        TInput* xPtr = px;
+                        TOutput* dPtr = pd;
 
                         // We need to the ensure the underlying data can be aligned and only align
                         // it if it can. It is possible we have an unaligned ref, in which case we
                         // can never achieve the required SIMD alignment.
 
-                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(TInput)) == 0;
 
                         if (canAlign)
                         {
@@ -3357,96 +3374,96 @@ static void Vectorized256(ref T xRef, ref T dRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T);
+                            nuint misalignment = ((uint)sizeof(Vector256<TInput>) - ((nuint)dPtr % (uint)sizeof(Vector256<TInput>))) / (uint)sizeof(TInput);
 
                             xPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<TInput>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector256<T> vector1;
-                        Vector256<T> vector2;
-                        Vector256<T> vector3;
-                        Vector256<T> vector4;
+                        Vector256<TOutput> vector1;
+                        Vector256<TOutput> vector2;
+                        Vector256<TOutput> vector3;
+                        Vector256<TOutput> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(TInput))) && canAlign)
                         {
                             // This loop stores the data non-temporally, which benefits us when there
                             // is a large amount of data involved as it avoids polluting the cache.
 
-                            while (remainder >= (uint)(Vector256<T>.Count * 8))
+                            while (remainder >= (uint)(Vector256<TInput>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)));
+                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 0)));
+                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 1)));
+                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 2)));
+                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 3)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 3));
+                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 0));
+                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 1));
+                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 2));
+                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 3));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)));
+                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 4)));
+                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 5)));
+                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 6)));
+                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 7)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<T>.Count * 7));
+                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 4));
+                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 5));
+                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 6));
+                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<TOutput>.Count * 7));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<T>.Count * 8);
-                                dPtr += (uint)(Vector256<T>.Count * 8);
+                                xPtr += (uint)(Vector256<TInput>.Count * 8);
+                                dPtr += (uint)(Vector256<TOutput>.Count * 8);
 
-                                remainder -= (uint)(Vector256<T>.Count * 8);
+                                remainder -= (uint)(Vector256<TInput>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector256<T>.Count * 8))
+                            while (remainder >= (uint)(Vector256<TInput>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)));
+                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 0)));
+                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 1)));
+                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 2)));
+                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 3)));
 
-                                vector1.Store(dPtr + (uint)(Vector256<T>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector256<T>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector256<T>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector256<T>.Count * 3));
+                                vector1.Store(dPtr + (uint)(Vector256<TOutput>.Count * 0));
+                                vector2.Store(dPtr + (uint)(Vector256<TOutput>.Count * 1));
+                                vector3.Store(dPtr + (uint)(Vector256<TOutput>.Count * 2));
+                                vector4.Store(dPtr + (uint)(Vector256<TOutput>.Count * 3));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)));
+                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 4)));
+                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 5)));
+                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 6)));
+                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<TInput>.Count * 7)));
 
-                                vector1.Store(dPtr + (uint)(Vector256<T>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector256<T>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector256<T>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector256<T>.Count * 7));
+                                vector1.Store(dPtr + (uint)(Vector256<TOutput>.Count * 4));
+                                vector2.Store(dPtr + (uint)(Vector256<TOutput>.Count * 5));
+                                vector3.Store(dPtr + (uint)(Vector256<TOutput>.Count * 6));
+                                vector4.Store(dPtr + (uint)(Vector256<TOutput>.Count * 7));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<T>.Count * 8);
-                                dPtr += (uint)(Vector256<T>.Count * 8);
+                                xPtr += (uint)(Vector256<TInput>.Count * 8);
+                                dPtr += (uint)(Vector256<TOutput>.Count * 8);
 
-                                remainder -= (uint)(Vector256<T>.Count * 8);
+                                remainder -= (uint)(Vector256<TInput>.Count * 8);
                             }
                         }
 
@@ -3465,63 +3482,63 @@ static void Vectorized256(ref T xRef, ref T dRef, nuint remainder)
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count);
+                remainder = (remainder + (uint)(Vector256<TInput>.Count - 1)) & (nuint)(-Vector256<TInput>.Count);
 
-                switch (remainder / (uint)Vector256<T>.Count)
+                switch (remainder / (uint)Vector256<TInput>.Count)
                 {
                     case 8:
                     {
-                        Vector256<T> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8));
+                        Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector256<T> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7));
+                        Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector256<T> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6));
+                        Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector256<T> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5));
+                        Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector256<T> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4));
+                        Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector256<T> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3));
+                        Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 3)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector256<T> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2));
+                        Vector256<TOutput> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<TInput>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<TOutput>.Count * 2));
                         goto case 1;
                     }
 
                     case 1:
                     {
                         // Store the last block, which includes any elements that wouldn't fill a full vector
-                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<TOutput>.Count);
                         goto case 0;
                     }
 
@@ -3534,31 +3551,31 @@ static void Vectorized256(ref T xRef, ref T dRef, nuint remainder)
                 }
             }
 
-            static void Vectorized512(ref T xRef, ref T dRef, nuint remainder)
+            static void Vectorized512(ref TInput xRef, ref TOutput dRef, nuint remainder)
             {
-                ref T dRefBeg = ref dRef;
+                ref TOutput dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector512<T> beg = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef));
-                Vector512<T> end = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count));
+                Vector512<TOutput> beg = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef));
+                Vector512<TOutput> end = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<TInput>.Count));
 
-                if (remainder > (uint)(Vector512<T>.Count * 8))
+                if (remainder > (uint)(Vector512<TInput>.Count * 8))
                 {
                     // Pinning is cheap and will be short lived for small inputs and unlikely to be impactful
                     // for large inputs (> 85KB) which are on the LOH and unlikely to be compacted.
 
-                    fixed (T* px = &xRef)
-                    fixed (T* pd = &dRef)
+                    fixed (TInput* px = &xRef)
+                    fixed (TOutput* pd = &dRef)
                     {
-                        T* xPtr = px;
-                        T* dPtr = pd;
+                        TInput* xPtr = px;
+                        TOutput* dPtr = pd;
 
                         // We need to the ensure the underlying data can be aligned and only align
                         // it if it can. It is possible we have an unaligned ref, in which case we
                         // can never achieve the required SIMD alignment.
 
-                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(TInput)) == 0;
 
                         if (canAlign)
                         {
@@ -3568,96 +3585,96 @@ static void Vectorized512(ref T xRef, ref T dRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T);
+                            nuint misalignment = ((uint)sizeof(Vector512<TInput>) - ((nuint)dPtr % (uint)sizeof(Vector512<TInput>))) / (uint)sizeof(TInput);
 
                             xPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<TInput>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector512<T> vector1;
-                        Vector512<T> vector2;
-                        Vector512<T> vector3;
-                        Vector512<T> vector4;
+                        Vector512<TOutput> vector1;
+                        Vector512<TOutput> vector2;
+                        Vector512<TOutput> vector3;
+                        Vector512<TOutput> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(TInput))) && canAlign)
                         {
                             // This loop stores the data non-temporally, which benefits us when there
                             // is a large amount of data involved as it avoids polluting the cache.
 
-                            while (remainder >= (uint)(Vector512<T>.Count * 8))
+                            while (remainder >= (uint)(Vector512<TInput>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)));
+                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 0)));
+                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 1)));
+                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 2)));
+                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 3)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 3));
+                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 0));
+                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 1));
+                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 2));
+                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 3));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)));
+                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 4)));
+                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 5)));
+                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 6)));
+                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 7)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<T>.Count * 7));
+                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 4));
+                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 5));
+                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 6));
+                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<TOutput>.Count * 7));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<T>.Count * 8);
-                                dPtr += (uint)(Vector512<T>.Count * 8);
+                                xPtr += (uint)(Vector512<TInput>.Count * 8);
+                                dPtr += (uint)(Vector512<TInput>.Count * 8);
 
-                                remainder -= (uint)(Vector512<T>.Count * 8);
+                                remainder -= (uint)(Vector512<TInput>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector512<T>.Count * 8))
+                            while (remainder >= (uint)(Vector512<TInput>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)));
+                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 0)));
+                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 1)));
+                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 2)));
+                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 3)));
 
-                                vector1.Store(dPtr + (uint)(Vector512<T>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector512<T>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector512<T>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector512<T>.Count * 3));
+                                vector1.Store(dPtr + (uint)(Vector512<TOutput>.Count * 0));
+                                vector2.Store(dPtr + (uint)(Vector512<TOutput>.Count * 1));
+                                vector3.Store(dPtr + (uint)(Vector512<TOutput>.Count * 2));
+                                vector4.Store(dPtr + (uint)(Vector512<TOutput>.Count * 3));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)));
+                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 4)));
+                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 5)));
+                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 6)));
+                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<TInput>.Count * 7)));
 
-                                vector1.Store(dPtr + (uint)(Vector512<T>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector512<T>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector512<T>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector512<T>.Count * 7));
+                                vector1.Store(dPtr + (uint)(Vector512<TOutput>.Count * 4));
+                                vector2.Store(dPtr + (uint)(Vector512<TOutput>.Count * 5));
+                                vector3.Store(dPtr + (uint)(Vector512<TOutput>.Count * 6));
+                                vector4.Store(dPtr + (uint)(Vector512<TOutput>.Count * 7));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<T>.Count * 8);
-                                dPtr += (uint)(Vector512<T>.Count * 8);
+                                xPtr += (uint)(Vector512<TInput>.Count * 8);
+                                dPtr += (uint)(Vector512<TOutput>.Count * 8);
 
-                                remainder -= (uint)(Vector512<T>.Count * 8);
+                                remainder -= (uint)(Vector512<TInput>.Count * 8);
                             }
                         }
 
@@ -3676,63 +3693,63 @@ static void Vectorized512(ref T xRef, ref T dRef, nuint remainder)
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count);
+                remainder = (remainder + (uint)(Vector512<TInput>.Count - 1)) & (nuint)(-Vector512<TInput>.Count);
 
-                switch (remainder / (uint)Vector512<T>.Count)
+                switch (remainder / (uint)Vector512<TInput>.Count)
                 {
                     case 8:
                     {
-                        Vector512<T> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8));
+                        Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector512<T> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7));
+                        Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector512<T> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6));
+                        Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector512<T> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5));
+                        Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector512<T> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4));
+                        Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector512<T> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3));
+                        Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 3)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector512<T> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 2));
+                        Vector512<TOutput> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<TInput>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<TOutput>.Count * 2));
                         goto case 1;
                     }
 
                     case 1:
                     {
                         // Store the last block, which includes any elements that wouldn't fill a full vector
-                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<TOutput>.Count);
                         goto case 0;
                     }
 
@@ -3746,23 +3763,23 @@ static void Vectorized512(ref T xRef, ref T dRef, nuint remainder)
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void VectorizedSmall(ref T xRef, ref T dRef, nuint remainder)
+            static void VectorizedSmall(ref TInput xRef, ref TOutput dRef, nuint remainder)
             {
-                if (sizeof(T) == 4)
+                if (sizeof(TInput) == 4)
                 {
                     VectorizedSmall4(ref xRef, ref dRef, remainder);
                 }
                 else
                 {
-                    Debug.Assert(sizeof(T) == 8);
+                    Debug.Assert(sizeof(TInput) == 8);
                     VectorizedSmall8(ref xRef, ref dRef, remainder);
                 }
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void VectorizedSmall4(ref T xRef, ref T dRef, nuint remainder)
+            static void VectorizedSmall4(ref TInput xRef, ref TOutput dRef, nuint remainder)
             {
-                Debug.Assert(sizeof(T) == 4);
+                Debug.Assert(sizeof(TInput) == 4);
 
                 switch (remainder)
                 {
@@ -3776,11 +3793,11 @@ static void VectorizedSmall4(ref T xRef, ref T dRef, nuint remainder)
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<T> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
-                        Vector256<T> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count));
+                        Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
+                        Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<TOutput>.Count);
 
                         break;
                     }
@@ -3789,7 +3806,7 @@ static void VectorizedSmall4(ref T xRef, ref T dRef, nuint remainder)
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<T> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
+                        Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -3801,11 +3818,11 @@ static void VectorizedSmall4(ref T xRef, ref T dRef, nuint remainder)
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<T> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
-                        Vector128<T> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count));
+                        Vector128<TOutput> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<TOutput> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<TInput>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<TOutput>.Count);
 
                         break;
                     }
@@ -3814,7 +3831,7 @@ static void VectorizedSmall4(ref T xRef, ref T dRef, nuint remainder)
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<T> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<TOutput> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -3846,9 +3863,9 @@ static void VectorizedSmall4(ref T xRef, ref T dRef, nuint remainder)
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void VectorizedSmall8(ref T xRef, ref T dRef, nuint remainder)
+            static void VectorizedSmall8(ref TInput xRef, ref TOutput dRef, nuint remainder)
             {
-                Debug.Assert(sizeof(T) == 8);
+                Debug.Assert(sizeof(TInput) == 8);
 
                 switch (remainder)
                 {
@@ -3858,11 +3875,11 @@ static void VectorizedSmall8(ref T xRef, ref T dRef, nuint remainder)
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<T> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
-                        Vector256<T> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count));
+                        Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
+                        Vector256<TOutput> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<TInput>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<TOutput>.Count);
 
                         break;
                     }
@@ -3871,7 +3888,7 @@ static void VectorizedSmall8(ref T xRef, ref T dRef, nuint remainder)
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<T> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
+                        Vector256<TOutput> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -3881,11 +3898,11 @@ static void VectorizedSmall8(ref T xRef, ref T dRef, nuint remainder)
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<T> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
-                        Vector128<T> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count));
+                        Vector128<TOutput> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<TOutput> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<TInput>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<TOutput>.Count);
 
                         break;
                     }
@@ -3894,7 +3911,7 @@ static void VectorizedSmall8(ref T xRef, ref T dRef, nuint remainder)
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<T> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<TOutput> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -3902,16 +3919,268 @@ static void VectorizedSmall8(ref T xRef, ref T dRef, nuint remainder)
 
                     case 1:
                     {
-                        dRef = TUnaryOperator.Invoke(xRef);
-                        goto case 0;
+                        dRef = TUnaryOperator.Invoke(xRef);
+                        goto case 0;
+                    }
+
+                    case 0:
+                    {
+                        break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>Performs an element-wise operation on <paramref name="x"/> and writes the results to <paramref name="destination"/>.</summary>
+        /// <typeparam name="TInput">The element input type.</typeparam>
+        /// <typeparam name="TOutput">The element output type. Must be the same size as TInput if TInput and TOutput both support vectorization.</typeparam>
+        /// <typeparam name="TUnaryOperator">Specifies the operation to perform on each element loaded from <paramref name="x"/>.</typeparam>
+        /// <remarks>This should only be used when it's known that TInput/TOutput are vectorizable and the size of TInput is twice that of TOutput.</remarks>
+        private static void InvokeSpanIntoSpan_2to1<TInput, TOutput, TUnaryOperator>(
+            ReadOnlySpan<TInput> x, Span<TOutput> destination)
+            where TUnaryOperator : struct, IUnaryTwoToOneOperator<TInput, TOutput>
+        {
+            Debug.Assert(sizeof(TInput) == sizeof(TOutput) * 2);
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            ref TInput xRef = ref MemoryMarshal.GetReference(x);
+            ref TOutput destinationRef = ref MemoryMarshal.GetReference(destination);
+            int i = 0, twoVectorsFromEnd;
+
+            if (Vector512.IsHardwareAccelerated && TUnaryOperator.Vectorizable)
+            {
+                Debug.Assert(Vector512<TInput>.IsSupported);
+                Debug.Assert(Vector512<TOutput>.IsSupported);
+
+                twoVectorsFromEnd = x.Length - (Vector512<TInput>.Count * 2);
+                if (i <= twoVectorsFromEnd)
+                {
+                    // Loop handling two input vectors / one output vector at a time.
+                    do
+                    {
+                        TUnaryOperator.Invoke(
+                            Vector512.LoadUnsafe(ref xRef, (uint)i),
+                            Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i);
+
+                        i += Vector512<TInput>.Count * 2;
+                    }
+                    while (i <= twoVectorsFromEnd);
+
+                    // Handle any remaining elements with final vectors.
+                    if (i != x.Length)
+                    {
+                        i = x.Length - (Vector512<TInput>.Count * 2);
+
+                        TUnaryOperator.Invoke(
+                            Vector512.LoadUnsafe(ref xRef, (uint)i),
+                            Vector512.LoadUnsafe(ref xRef, (uint)(i + Vector512<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i);
+                    }
+
+                    return;
+                }
+            }
+
+            if (Vector256.IsHardwareAccelerated && TUnaryOperator.Vectorizable)
+            {
+                Debug.Assert(Vector256<TInput>.IsSupported);
+                Debug.Assert(Vector256<TOutput>.IsSupported);
+
+                twoVectorsFromEnd = x.Length - (Vector256<TInput>.Count * 2);
+                if (i <= twoVectorsFromEnd)
+                {
+                    // Loop handling two input vectors / one output vector at a time.
+                    do
+                    {
+                        TUnaryOperator.Invoke(
+                            Vector256.LoadUnsafe(ref xRef, (uint)i),
+                            Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i);
+
+                        i += Vector256<TInput>.Count * 2;
+                    }
+                    while (i <= twoVectorsFromEnd);
+
+                    // Handle any remaining elements with final vectors.
+                    if (i != x.Length)
+                    {
+                        i = x.Length - (Vector256<TInput>.Count * 2);
+
+                        TUnaryOperator.Invoke(
+                            Vector256.LoadUnsafe(ref xRef, (uint)i),
+                            Vector256.LoadUnsafe(ref xRef, (uint)(i + Vector256<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i);
+                    }
+
+                    return;
+                }
+            }
+
+            if (Vector128.IsHardwareAccelerated && TUnaryOperator.Vectorizable)
+            {
+                Debug.Assert(Vector128<TInput>.IsSupported);
+                Debug.Assert(Vector128<TOutput>.IsSupported);
+
+                twoVectorsFromEnd = x.Length - (Vector128<TInput>.Count * 2);
+                if (i <= twoVectorsFromEnd)
+                {
+                    // Loop handling two input vectors / one output vector at a time.
+                    do
+                    {
+                        TUnaryOperator.Invoke(
+                            Vector128.LoadUnsafe(ref xRef, (uint)i),
+                            Vector128.LoadUnsafe(ref xRef, (uint)(i + Vector128<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i);
+
+                        i += Vector128<TInput>.Count * 2;
+                    }
+                    while (i <= twoVectorsFromEnd);
+
+                    // Handle any remaining elements with final vectors.
+                    if (i != x.Length)
+                    {
+                        i = x.Length - (Vector128<TInput>.Count * 2);
+
+                        TUnaryOperator.Invoke(
+                            Vector128.LoadUnsafe(ref xRef, (uint)i),
+                            Vector128.LoadUnsafe(ref xRef, (uint)(i + Vector128<TInput>.Count))).StoreUnsafe(ref destinationRef, (uint)i);
+                    }
+
+                    return;
+                }
+            }
+
+            while (i < x.Length)
+            {
+                Unsafe.Add(ref destinationRef, i) = TUnaryOperator.Invoke(Unsafe.Add(ref xRef, i));
+                i++;
+            }
+        }
+
+        /// <summary>Performs an element-wise operation on <paramref name="x"/> and writes the results to <paramref name="destination"/>.</summary>
+        /// <typeparam name="TInput">The element input type.</typeparam>
+        /// <typeparam name="TOutput">The element output type. Must be the same size as TInput if TInput and TOutput both support vectorization.</typeparam>
+        /// <typeparam name="TUnaryOperator">Specifies the operation to perform on each element loaded from <paramref name="x"/>.</typeparam>
+        /// <remarks>This should only be used when it's known that TInput/TOutput are vectorizable and the size of TInput is half that of TOutput.</remarks>
+        private static void InvokeSpanIntoSpan_1to2<TInput, TOutput, TUnaryOperator>(
+            ReadOnlySpan<TInput> x, Span<TOutput> destination)
+            where TUnaryOperator : struct, IUnaryOneToTwoOperator<TInput, TOutput>
+        {
+            Debug.Assert(sizeof(TInput) * 2 == sizeof(TOutput));
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            ref TInput sourceRef = ref MemoryMarshal.GetReference(x);
+            ref TOutput destinationRef = ref MemoryMarshal.GetReference(destination);
+            int i = 0, oneVectorFromEnd;
+
+            if (Vector512.IsHardwareAccelerated && TUnaryOperator.Vectorizable)
+            {
+                Debug.Assert(Vector512<TInput>.IsSupported);
+                Debug.Assert(Vector512<TOutput>.IsSupported);
+
+                oneVectorFromEnd = x.Length - Vector512<TInput>.Count;
+                if (i <= oneVectorFromEnd)
+                {
+                    // Loop handling one input vector / two output vectors at a time.
+                    do
+                    {
+                        (Vector512<TOutput> lower, Vector512<TOutput> upper) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i));
+                        lower.StoreUnsafe(ref destinationRef, (uint)i);
+                        upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector512<TOutput>.Count));
+
+                        i += Vector512<TInput>.Count;
+                    }
+                    while (i <= oneVectorFromEnd);
+
+                    // Handle any remaining elements with a final input vector.
+                    if (i != x.Length)
+                    {
+                        i = x.Length - Vector512<TInput>.Count;
+
+                        (Vector512<TOutput> lower, Vector512<TOutput> upper) = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref sourceRef, (uint)i));
+                        lower.StoreUnsafe(ref destinationRef, (uint)i);
+                        upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector512<TOutput>.Count));
+                    }
+
+                    return;
+                }
+            }
+
+            if (Vector256.IsHardwareAccelerated && TUnaryOperator.Vectorizable)
+            {
+                Debug.Assert(Vector256<TInput>.IsSupported);
+                Debug.Assert(Vector256<TOutput>.IsSupported);
+
+                oneVectorFromEnd = x.Length - Vector256<TInput>.Count;
+                if (i <= oneVectorFromEnd)
+                {
+                    // Loop handling one input vector / two output vectors at a time.
+                    do
+                    {
+                        (Vector256<TOutput> lower, Vector256<TOutput> upper) = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref sourceRef, (uint)i));
+                        lower.StoreUnsafe(ref destinationRef, (uint)i);
+                        upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector256<TOutput>.Count));
+
+                        i += Vector256<TInput>.Count;
+                    }
+                    while (i <= oneVectorFromEnd);
+
+                    // Handle any remaining elements with a final input vector.
+                    if (i != x.Length)
+                    {
+                        i = x.Length - Vector256<TInput>.Count;
+
+                        (Vector256<TOutput> lower, Vector256<TOutput> upper) = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref sourceRef, (uint)i));
+                        lower.StoreUnsafe(ref destinationRef, (uint)i);
+                        upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector256<TOutput>.Count));
+                    }
+
+                    return;
+                }
+            }
+
+            if (Vector128.IsHardwareAccelerated && TUnaryOperator.Vectorizable)
+            {
+                Debug.Assert(Vector128<TInput>.IsSupported);
+                Debug.Assert(Vector128<TOutput>.IsSupported);
+
+                oneVectorFromEnd = x.Length - Vector128<TInput>.Count;
+                if (i <= oneVectorFromEnd)
+                {
+                    // Loop handling one input vector / two output vectors at a time.
+                    do
+                    {
+                        (Vector128<TOutput> lower, Vector128<TOutput> upper) = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref sourceRef, (uint)i));
+                        lower.StoreUnsafe(ref destinationRef, (uint)i);
+                        upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector128<TOutput>.Count));
+
+                        i += Vector128<TInput>.Count;
                     }
+                    while (i <= oneVectorFromEnd);
 
-                    case 0:
+                    // Handle any remaining elements with a final input vector.
+                    if (i != x.Length)
                     {
-                        break;
+                        i = x.Length - Vector128<TInput>.Count;
+
+                        (Vector128<TOutput> lower, Vector128<TOutput> upper) = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref sourceRef, (uint)i));
+                        lower.StoreUnsafe(ref destinationRef, (uint)i);
+                        upper.StoreUnsafe(ref destinationRef, (uint)(i + Vector128<TOutput>.Count));
                     }
+
+                    return;
                 }
             }
+
+            while (i < x.Length)
+            {
+                Unsafe.Add(ref destinationRef, i) = TUnaryOperator.Invoke(Unsafe.Add(ref sourceRef, i));
+                i++;
+            }
         }
 
         /// <summary>
@@ -4968,7 +5237,7 @@ private static void InvokeSpanScalarIntoSpan<T, TBinaryOperator>(
         /// </typeparam>
         private static void InvokeSpanScalarIntoSpan<T, TTransformOperator, TBinaryOperator>(
             ReadOnlySpan<T> x, T y, Span<T> destination)
-            where TTransformOperator : struct, IUnaryOperator<T>
+            where TTransformOperator : struct, IUnaryOperator<T, T>
             where TBinaryOperator : struct, IBinaryOperator<T>
         {
             if (x.Length > destination.Length)
@@ -5866,7 +6135,7 @@ static void VectorizedSmall4(ref T xRef, T y, ref T dRef, nuint remainder)
                     case 2:
                     {
                         Unsafe.Add(ref dRef, 1) = TBinaryOperator.Invoke(TTransformOperator.Invoke(Unsafe.Add(ref xRef, 1)),
-                                                                         y);
+                                                                          y);
                         goto case 1;
                     }
 
@@ -7037,8 +7306,8 @@ static void VectorizedSmall8(ref T xRef, ref T yRef, ref T zRef, ref T dRef, nui
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
                         Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                       Vector256.LoadUnsafe(ref yRef),
-                                                                       Vector256.LoadUnsafe(ref zRef));
+                                                                   Vector256.LoadUnsafe(ref yRef),
+                                                                   Vector256.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -7049,11 +7318,11 @@ static void VectorizedSmall8(ref T xRef, ref T yRef, ref T zRef, ref T dRef, nui
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
                         Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.LoadUnsafe(ref yRef),
-                                                                       Vector128.LoadUnsafe(ref zRef));
+                                                                   Vector128.LoadUnsafe(ref yRef),
+                                                                   Vector128.LoadUnsafe(ref zRef));
                         Vector128<T> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
-                                                                       Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count),
-                                                                       Vector128.LoadUnsafe(ref zRef, remainder - (uint)Vector128<T>.Count));
+                                                                   Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count),
+                                                                   Vector128.LoadUnsafe(ref zRef, remainder - (uint)Vector128<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
                         end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
@@ -7066,8 +7335,8 @@ static void VectorizedSmall8(ref T xRef, ref T yRef, ref T zRef, ref T dRef, nui
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
                         Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.LoadUnsafe(ref yRef),
-                                                                       Vector128.LoadUnsafe(ref zRef));
+                                                                   Vector128.LoadUnsafe(ref yRef),
+                                                                   Vector128.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -7387,8 +7656,8 @@ static void Vectorized128(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 8:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 8)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 8)),
-                                                                          zVec);
+                                                                      Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 8)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 8));
                         goto case 7;
                     }
@@ -7396,8 +7665,8 @@ static void Vectorized128(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 7:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 7)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 7)),
-                                                                          zVec);
+                                                                      Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 7)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 7));
                         goto case 6;
                     }
@@ -7405,8 +7674,8 @@ static void Vectorized128(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 6:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 6)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 6)),
-                                                                          zVec);
+                                                                      Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 6)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 6));
                         goto case 5;
                     }
@@ -7414,8 +7683,8 @@ static void Vectorized128(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 5:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 5)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 5)),
-                                                                          zVec);
+                                                                      Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 5)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 5));
                         goto case 4;
                     }
@@ -7423,8 +7692,8 @@ static void Vectorized128(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 4:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 4)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 4)),
-                                                                          zVec);
+                                                                      Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 4)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 4));
                         goto case 3;
                     }
@@ -7432,8 +7701,8 @@ static void Vectorized128(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 3:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 3)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 3)),
-                                                                          zVec);
+                                                                      Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 3)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 3));
                         goto case 2;
                     }
@@ -7441,8 +7710,8 @@ static void Vectorized128(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 2:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 2)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 2)),
-                                                                          zVec);
+                                                                      Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 2)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 2));
                         goto case 1;
                     }
@@ -7656,8 +7925,8 @@ static void Vectorized256(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 8:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 8)),
-                                                                          zVec);
+                                                                      Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 8)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8));
                         goto case 7;
                     }
@@ -7665,8 +7934,8 @@ static void Vectorized256(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 7:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7)),
-                                                                          zVec);
+                                                                      Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7));
                         goto case 6;
                     }
@@ -7674,8 +7943,8 @@ static void Vectorized256(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 6:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6)),
-                                                                          zVec);
+                                                                      Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6));
                         goto case 5;
                     }
@@ -7683,8 +7952,8 @@ static void Vectorized256(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 5:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5)),
-                                                                          zVec);
+                                                                      Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5));
                         goto case 4;
                     }
@@ -7692,8 +7961,8 @@ static void Vectorized256(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 4:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4)),
-                                                                          zVec);
+                                                                      Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4));
                         goto case 3;
                     }
@@ -7701,8 +7970,8 @@ static void Vectorized256(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 3:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3)),
-                                                                          zVec);
+                                                                      Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3));
                         goto case 2;
                     }
@@ -7710,8 +7979,8 @@ static void Vectorized256(ref T xRef, ref T yRef, T z, ref T dRef, nuint remaind
                     case 2:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2)),
-                                                                          zVec);
+                                                                      Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2)),
+                                                                      zVec);
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2));
                         goto case 1;
                     }
@@ -8035,11 +8304,11 @@ static void VectorizedSmall4(ref T xRef, ref T yRef, T z, ref T dRef, nuint rema
                         Vector256<T> zVec = Vector256.Create(z);
 
                         Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                       Vector256.LoadUnsafe(ref yRef),
-                                                                       zVec);
+                                                                   Vector256.LoadUnsafe(ref yRef),
+                                                                   zVec);
                         Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
-                                                                       Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count),
-                                                                       zVec);
+                                                                   Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count),
+                                                                   zVec);
 
                         beg.StoreUnsafe(ref dRef);
                         end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
@@ -8052,8 +8321,8 @@ static void VectorizedSmall4(ref T xRef, ref T yRef, T z, ref T dRef, nuint rema
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
                         Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                       Vector256.LoadUnsafe(ref yRef),
-                                                                       Vector256.Create(z));
+                                                                   Vector256.LoadUnsafe(ref yRef),
+                                                                   Vector256.Create(z));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -8068,11 +8337,11 @@ static void VectorizedSmall4(ref T xRef, ref T yRef, T z, ref T dRef, nuint rema
                         Vector128<T> zVec = Vector128.Create(z);
 
                         Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.LoadUnsafe(ref yRef),
-                                                                       zVec);
+                                                                   Vector128.LoadUnsafe(ref yRef),
+                                                                   zVec);
                         Vector128<T> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
-                                                                       Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count),
-                                                                       zVec);
+                                                                   Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count),
+                                                                   zVec);
 
                         beg.StoreUnsafe(ref dRef);
                         end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
@@ -8085,8 +8354,8 @@ static void VectorizedSmall4(ref T xRef, ref T yRef, T z, ref T dRef, nuint rema
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
                         Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.LoadUnsafe(ref yRef),
-                                                                       Vector128.Create(z));
+                                                                   Vector128.LoadUnsafe(ref yRef),
+                                                                   Vector128.Create(z));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -8137,11 +8406,11 @@ static void VectorizedSmall8(ref T xRef, ref T yRef, T z, ref T dRef, nuint rema
                         Vector256<T> zVec = Vector256.Create(z);
 
                         Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                       Vector256.LoadUnsafe(ref yRef),
-                                                                       zVec);
+                                                                   Vector256.LoadUnsafe(ref yRef),
+                                                                   zVec);
                         Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
-                                                                       Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count),
-                                                                       zVec);
+                                                                   Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count),
+                                                                   zVec);
 
                         beg.StoreUnsafe(ref dRef);
                         end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
@@ -8154,8 +8423,8 @@ static void VectorizedSmall8(ref T xRef, ref T yRef, T z, ref T dRef, nuint rema
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
                         Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                       Vector256.LoadUnsafe(ref yRef),
-                                                                       Vector256.Create(z));
+                                                                   Vector256.LoadUnsafe(ref yRef),
+                                                                   Vector256.Create(z));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -8168,11 +8437,11 @@ static void VectorizedSmall8(ref T xRef, ref T yRef, T z, ref T dRef, nuint rema
                         Vector128<T> zVec = Vector128.Create(z);
 
                         Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.LoadUnsafe(ref yRef),
-                                                                       zVec);
+                                                                   Vector128.LoadUnsafe(ref yRef),
+                                                                   zVec);
                         Vector128<T> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
-                                                                       Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count),
-                                                                       zVec);
+                                                                   Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count),
+                                                                   zVec);
 
                         beg.StoreUnsafe(ref dRef);
                         end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
@@ -8185,8 +8454,8 @@ static void VectorizedSmall8(ref T xRef, ref T yRef, T z, ref T dRef, nuint rema
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
                         Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.LoadUnsafe(ref yRef),
-                                                                       Vector128.Create(z));
+                                                                   Vector128.LoadUnsafe(ref yRef),
+                                                                   Vector128.Create(z));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -8506,8 +8775,8 @@ static void Vectorized128(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 8:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 8)),
-                                                                          yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 8)));
+                                                                      yVec,
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 8)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 8));
                         goto case 7;
                     }
@@ -8515,8 +8784,8 @@ static void Vectorized128(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 7:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 7)),
-                                                                          yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 7)));
+                                                                      yVec,
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 7)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 7));
                         goto case 6;
                     }
@@ -8524,8 +8793,8 @@ static void Vectorized128(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 6:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 6)),
-                                                                          yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 6)));
+                                                                      yVec,
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 6)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 6));
                         goto case 5;
                     }
@@ -8533,8 +8802,8 @@ static void Vectorized128(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 5:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 5)),
-                                                                          yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 5)));
+                                                                      yVec,
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 5)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 5));
                         goto case 4;
                     }
@@ -8542,8 +8811,8 @@ static void Vectorized128(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 4:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 4)),
-                                                                          yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 4)));
+                                                                      yVec,
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 4)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 4));
                         goto case 3;
                     }
@@ -8551,8 +8820,8 @@ static void Vectorized128(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 3:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 3)),
-                                                                          yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 3)));
+                                                                      yVec,
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 3)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 3));
                         goto case 2;
                     }
@@ -8560,8 +8829,8 @@ static void Vectorized128(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 2:
                     {
                         Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 2)),
-                                                                          yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 2)));
+                                                                      yVec,
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 2)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 2));
                         goto case 1;
                     }
@@ -8775,8 +9044,8 @@ static void Vectorized256(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 8:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)),
-                                                                          yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 8)));
+                                                                      yVec,
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 8)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8));
                         goto case 7;
                     }
@@ -8784,8 +9053,8 @@ static void Vectorized256(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 7:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)),
-                                                                          yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 7)));
+                                                                      yVec,
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 7)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7));
                         goto case 6;
                     }
@@ -8793,8 +9062,8 @@ static void Vectorized256(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 6:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)),
-                                                                          yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 6)));
+                                                                      yVec,
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 6)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6));
                         goto case 5;
                     }
@@ -8802,8 +9071,8 @@ static void Vectorized256(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 5:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)),
-                                                                          yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 5)));
+                                                                      yVec,
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 5)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5));
                         goto case 4;
                     }
@@ -8811,8 +9080,8 @@ static void Vectorized256(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 4:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)),
-                                                                          yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 4)));
+                                                                      yVec,
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 4)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4));
                         goto case 3;
                     }
@@ -8820,8 +9089,8 @@ static void Vectorized256(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 3:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)),
-                                                                          yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 3)));
+                                                                      yVec,
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 3)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3));
                         goto case 2;
                     }
@@ -8829,8 +9098,8 @@ static void Vectorized256(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 2:
                     {
                         Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)),
-                                                                          yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 2)));
+                                                                      yVec,
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 2)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 2));
                         goto case 1;
                     }
@@ -9044,8 +9313,8 @@ static void Vectorized512(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 8:
                     {
                         Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)),
-                                                                          yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 8)));
+                                                                      yVec,
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 8)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8));
                         goto case 7;
                     }
@@ -9053,8 +9322,8 @@ static void Vectorized512(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 7:
                     {
                         Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)),
-                                                                          yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 7)));
+                                                                      yVec,
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 7)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7));
                         goto case 6;
                     }
@@ -9062,8 +9331,8 @@ static void Vectorized512(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 6:
                     {
                         Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)),
-                                                                          yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 6)));
+                                                                      yVec,
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 6)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6));
                         goto case 5;
                     }
@@ -9071,8 +9340,8 @@ static void Vectorized512(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 5:
                     {
                         Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)),
-                                                                          yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 5)));
+                                                                      yVec,
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 5)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5));
                         goto case 4;
                     }
@@ -9080,8 +9349,8 @@ static void Vectorized512(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 4:
                     {
                         Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)),
-                                                                          yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 4)));
+                                                                      yVec,
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 4)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4));
                         goto case 3;
                     }
@@ -9089,8 +9358,8 @@ static void Vectorized512(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 3:
                     {
                         Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)),
-                                                                          yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 3)));
+                                                                      yVec,
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 3)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3));
                         goto case 2;
                     }
@@ -9098,8 +9367,8 @@ static void Vectorized512(ref T xRef, T y, ref T zRef, ref T dRef, nuint remaind
                     case 2:
                     {
                         Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)),
-                                                                          yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 2)));
+                                                                      yVec,
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 2)));
                         vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 2));
                         goto case 1;
                     }
@@ -9154,11 +9423,11 @@ static void VectorizedSmall4(ref T xRef, T y, ref T zRef, ref T dRef, nuint rema
                         Vector256<T> yVec = Vector256.Create(y);
 
                         Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                       yVec,
-                                                                       Vector256.LoadUnsafe(ref zRef));
+                                                                   yVec,
+                                                                   Vector256.LoadUnsafe(ref zRef));
                         Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
-                                                                       yVec,
-                                                                       Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count));
+                                                                   yVec,
+                                                                   Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
                         end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
@@ -9171,8 +9440,8 @@ static void VectorizedSmall4(ref T xRef, T y, ref T zRef, ref T dRef, nuint rema
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
                         Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                       Vector256.Create(y),
-                                                                       Vector256.LoadUnsafe(ref zRef));
+                                                                   Vector256.Create(y),
+                                                                   Vector256.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -9187,11 +9456,11 @@ static void VectorizedSmall4(ref T xRef, T y, ref T zRef, ref T dRef, nuint rema
                         Vector128<T> yVec = Vector128.Create(y);
 
                         Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       yVec,
-                                                                       Vector128.LoadUnsafe(ref zRef));
+                                                                   yVec,
+                                                                   Vector128.LoadUnsafe(ref zRef));
                         Vector128<T> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
-                                                                       yVec,
-                                                                       Vector128.LoadUnsafe(ref zRef, remainder - (uint)Vector128<T>.Count));
+                                                                   yVec,
+                                                                   Vector128.LoadUnsafe(ref zRef, remainder - (uint)Vector128<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
                         end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
@@ -9204,8 +9473,8 @@ static void VectorizedSmall4(ref T xRef, T y, ref T zRef, ref T dRef, nuint rema
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
                         Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.Create(y),
-                                                                       Vector128.LoadUnsafe(ref zRef));
+                                                                   Vector128.Create(y),
+                                                                   Vector128.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -9256,11 +9525,11 @@ static void VectorizedSmall8(ref T xRef, T y, ref T zRef, ref T dRef, nuint rema
                         Vector256<T> yVec = Vector256.Create(y);
 
                         Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                       yVec,
-                                                                       Vector256.LoadUnsafe(ref zRef));
+                                                                   yVec,
+                                                                   Vector256.LoadUnsafe(ref zRef));
                         Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
-                                                                       yVec,
-                                                                       Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count));
+                                                                   yVec,
+                                                                   Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
                         end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
@@ -9273,8 +9542,8 @@ static void VectorizedSmall8(ref T xRef, T y, ref T zRef, ref T dRef, nuint rema
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
                         Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                       Vector256.Create(y),
-                                                                       Vector256.LoadUnsafe(ref zRef));
+                                                                   Vector256.Create(y),
+                                                                   Vector256.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -9287,11 +9556,11 @@ static void VectorizedSmall8(ref T xRef, T y, ref T zRef, ref T dRef, nuint rema
                         Vector128<T> yVec = Vector128.Create(y);
 
                         Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       yVec,
-                                                                       Vector128.LoadUnsafe(ref zRef));
+                                                                   yVec,
+                                                                   Vector128.LoadUnsafe(ref zRef));
                         Vector128<T> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
-                                                                       yVec,
-                                                                       Vector128.LoadUnsafe(ref zRef, remainder - (uint)Vector128<T>.Count));
+                                                                   yVec,
+                                                                   Vector128.LoadUnsafe(ref zRef, remainder - (uint)Vector128<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
                         end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
@@ -9304,8 +9573,8 @@ static void VectorizedSmall8(ref T xRef, T y, ref T zRef, ref T dRef, nuint rema
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
                         Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.Create(y),
-                                                                       Vector128.LoadUnsafe(ref zRef));
+                                                                   Vector128.Create(y),
+                                                                   Vector128.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -9740,6 +10009,32 @@ ref Unsafe.As<ulong, T>(ref MemoryMarshal.GetReference(RemainderUInt64Mask_8x9))
             throw new NotSupportedException();
         }
 
+        /// <summary>Creates a span of <typeparamref name="TTo"/> from a <typeparamref name="TTo"/> when they're the same type.</summary>
+        private static unsafe ReadOnlySpan<TTo> Rename<TFrom, TTo>(ReadOnlySpan<TFrom> span)
+        {
+            Debug.Assert(sizeof(TFrom) == sizeof(TTo));
+            return MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<TFrom, TTo>(ref MemoryMarshal.GetReference(span)), span.Length);
+        }
+
+        /// <summary>Creates a span of <typeparamref name="TTo"/> from a <typeparamref name="TTo"/> when they're the same type.</summary>
+        private static unsafe Span<TTo> Rename<TFrom, TTo>(Span<TFrom> span)
+        {
+            Debug.Assert(sizeof(TFrom) == sizeof(TTo));
+            return MemoryMarshal.CreateSpan(ref Unsafe.As<TFrom, TTo>(ref MemoryMarshal.GetReference(span)), span.Length);
+        }
+
+        /// <summary>Gets whether <typeparamref name="T"/> is <see cref="uint"/> or <see cref="nuint"/> if in a 32-bit process.</summary>
+        private static bool IsUInt32Like<T>() => typeof(T) == typeof(uint) || (IntPtr.Size == 4 && typeof(T) == typeof(nuint));
+
+        /// <summary>Gets whether <typeparamref name="T"/> is <see cref="int"/> or <see cref="nint"/> if in a 32-bit process.</summary>
+        private static bool IsInt32Like<T>() => typeof(T) == typeof(int) || (IntPtr.Size == 4 && typeof(T) == typeof(nint));
+
+        /// <summary>Gets whether <typeparamref name="T"/> is <see cref="ulong"/> or <see cref="nuint"/> if in a 64-bit process.</summary>
+        private static bool IsUInt64Like<T>() => typeof(T) == typeof(ulong) || (IntPtr.Size == 8 && typeof(T) == typeof(nuint));
+
+        /// <summary>Gets whether <typeparamref name="T"/> is <see cref="long"/> or <see cref="nint"/> if in a 64-bit process.</summary>
+        private static bool IsInt64Like<T>() => typeof(T) == typeof(long) || (IntPtr.Size == 8 && typeof(T) == typeof(nint));
+
         /// <summary>x + y</summary>
         internal readonly struct AddOperator<T> : IAggregationOperator<T> where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
         {
@@ -9846,7 +10141,7 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
 
         // Ieee754Remainder
 
-        internal readonly struct ReciprocalOperator<T> : IUnaryOperator<T> where T : IFloatingPoint<T>
+        internal readonly struct ReciprocalOperator<T> : IUnaryOperator<T, T> where T : IFloatingPoint<T>
         {
             public static bool Vectorizable => true;
             public static T Invoke(T x) => T.One / x;
@@ -9855,7 +10150,7 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
             public static Vector512<T> Invoke(Vector512<T> x) => Vector512<T>.One / x;
         }
 
-        private readonly struct ReciprocalSqrtOperator<T> : IUnaryOperator<T> where T : IFloatingPointIeee754<T>
+        private readonly struct ReciprocalSqrtOperator<T> : IUnaryOperator<T, T> where T : IFloatingPointIeee754<T>
         {
             public static bool Vectorizable => true;
             public static T Invoke(T x) => T.One / T.Sqrt(x);
@@ -9864,7 +10159,7 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
             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>
+        private readonly struct ReciprocalEstimateOperator<T> : IUnaryOperator<T, T> where T : IFloatingPointIeee754<T>
         {
             public static bool Vectorizable => true;
 
@@ -9912,7 +10207,7 @@ public static Vector512<T> Invoke(Vector512<T> x)
             }
         }
 
-        private readonly struct ReciprocalSqrtEstimateOperator<T> : IUnaryOperator<T> where T : IFloatingPointIeee754<T>
+        private readonly struct ReciprocalSqrtEstimateOperator<T> : IUnaryOperator<T, T> where T : IFloatingPointIeee754<T>
         {
             public static bool Vectorizable => true;
 
@@ -9991,7 +10286,7 @@ public static Vector512<T> Invoke(Vector512<T> x)
         }
 
         /// <summary>~x</summary>
-        internal readonly struct OnesComplementOperator<T> : IUnaryOperator<T> where T : IBitwiseOperators<T, T, T>
+        internal readonly struct OnesComplementOperator<T> : IUnaryOperator<T, T> where T : IBitwiseOperators<T, T, T>
         {
             public static bool Vectorizable => true;
             public static T Invoke(T x) => ~x;
@@ -11221,7 +11516,7 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         }
 
         /// <summary>-x</summary>
-        internal readonly struct NegateOperator<T> : IUnaryOperator<T> where T : IUnaryNegationOperators<T, T>
+        internal readonly struct NegateOperator<T> : IUnaryOperator<T, T> where T : IUnaryNegationOperators<T, T>
         {
             public static bool Vectorizable => true;
             public static T Invoke(T x) => -x;
@@ -11267,7 +11562,7 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         }
 
         /// <summary>x</summary>
-        internal readonly struct IdentityOperator<T> : IUnaryOperator<T>
+        internal readonly struct IdentityOperator<T> : IUnaryOperator<T, T>
         {
             public static bool Vectorizable => true;
             public static T Invoke(T x) => x;
@@ -11277,7 +11572,7 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         }
 
         /// <summary>x * x</summary>
-        internal readonly struct SquaredOperator<T> : IUnaryOperator<T> where T : IMultiplyOperators<T, T, T>
+        internal readonly struct SquaredOperator<T> : IUnaryOperator<T, T> where T : IMultiplyOperators<T, T, T>
         {
             public static bool Vectorizable => true;
             public static T Invoke(T x) => x * x;
@@ -11287,7 +11582,7 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         }
 
         /// <summary>T.Abs(x)</summary>
-        internal readonly struct AbsoluteOperator<T> : IUnaryOperator<T> where T : INumberBase<T>
+        internal readonly struct AbsoluteOperator<T> : IUnaryOperator<T, T> where T : INumberBase<T>
         {
             public static bool Vectorizable => true;
 
@@ -11367,7 +11662,7 @@ public static Vector512<T> Invoke(Vector512<T> x)
         }
 
         /// <summary>T.Exp(x)</summary>
-        internal readonly struct ExpOperator<T> : IUnaryOperator<T>
+        internal readonly struct ExpOperator<T> : IUnaryOperator<T, T>
             where T : IExponentialFunctions<T>
         {
             public static bool Vectorizable => (typeof(T) == typeof(double))
@@ -11453,7 +11748,7 @@ public static Vector512<T> Invoke(Vector512<T> x)
 
 #if !NET9_0_OR_GREATER
         /// <summary>double.Exp(x)</summary>
-        internal readonly struct ExpOperatorDouble : IUnaryOperator<double>
+        internal readonly struct ExpOperatorDouble : IUnaryOperator<double, double>
         {
             // This code is based on `vrd2_exp` from amd/aocl-libm-ose
             // Copyright (C) 2019-2020 Advanced Micro Devices, Inc. All rights reserved.
@@ -11672,7 +11967,7 @@ public static Vector512<double> Invoke(Vector512<double> x)
         }
 
         /// <summary>float.Exp(x)</summary>
-        internal readonly struct ExpOperatorSingle : IUnaryOperator<float>
+        internal readonly struct ExpOperatorSingle : IUnaryOperator<float, float>
         {
             // This code is based on `vrs4_expf` from amd/aocl-libm-ose
             // Copyright (C) 2019-2022 Advanced Micro Devices, Inc. All rights reserved.
@@ -11953,7 +12248,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
 #endif
 
         /// <summary>T.ExpM1(x)</summary>
-        internal readonly struct ExpM1Operator<T> : IUnaryOperator<T>
+        internal readonly struct ExpM1Operator<T> : IUnaryOperator<T, T>
             where T : IExponentialFunctions<T>
         {
             public static bool Vectorizable => ExpOperator<T>.Vectorizable;
@@ -11965,7 +12260,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Exp2(x)</summary>
-        internal readonly struct Exp2Operator<T> : IUnaryOperator<T>
+        internal readonly struct Exp2Operator<T> : IUnaryOperator<T, T>
             where T : IExponentialFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -11977,7 +12272,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Exp2M1(x)</summary>
-        internal readonly struct Exp2M1Operator<T> : IUnaryOperator<T>
+        internal readonly struct Exp2M1Operator<T> : IUnaryOperator<T, T>
             where T : IExponentialFunctions<T>
         {
             public static bool Vectorizable => Exp2Operator<T>.Vectorizable;
@@ -11989,7 +12284,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Exp10(x)</summary>
-        internal readonly struct Exp10Operator<T> : IUnaryOperator<T>
+        internal readonly struct Exp10Operator<T> : IUnaryOperator<T, T>
             where T : IExponentialFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -12001,7 +12296,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Exp10M1(x)</summary>
-        internal readonly struct Exp10M1Operator<T> : IUnaryOperator<T>
+        internal readonly struct Exp10M1Operator<T> : IUnaryOperator<T, T>
             where T : IExponentialFunctions<T>
         {
             public static bool Vectorizable => Exp2Operator<T>.Vectorizable;
@@ -12024,7 +12319,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Sqrt(x)</summary>
-        internal readonly struct SqrtOperator<T> : IUnaryOperator<T>
+        internal readonly struct SqrtOperator<T> : IUnaryOperator<T, T>
             where T : IRootFunctions<T>
         {
             public static bool Vectorizable => true;
@@ -12035,7 +12330,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Cbrt(x)</summary>
-        internal readonly struct CbrtOperator<T> : IUnaryOperator<T>
+        internal readonly struct CbrtOperator<T> : IUnaryOperator<T, T>
             where T : IRootFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -12057,7 +12352,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Acos(x)</summary>
-        internal readonly struct AcosOperator<T> : IUnaryOperator<T>
+        internal readonly struct AcosOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -12068,7 +12363,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Acosh(x)</summary>
-        internal readonly struct AcoshOperator<T> : IUnaryOperator<T>
+        internal readonly struct AcoshOperator<T> : IUnaryOperator<T, T>
             where T : IHyperbolicFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -12079,7 +12374,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.AcosPi(x)</summary>
-        internal readonly struct AcosPiOperator<T> : IUnaryOperator<T>
+        internal readonly struct AcosPiOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => AcosOperator<T>.Vectorizable;
@@ -12090,7 +12385,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Asin(x)</summary>
-        internal readonly struct AsinOperator<T> : IUnaryOperator<T>
+        internal readonly struct AsinOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -12101,7 +12396,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Asinh(x)</summary>
-        internal readonly struct AsinhOperator<T> : IUnaryOperator<T>
+        internal readonly struct AsinhOperator<T> : IUnaryOperator<T, T>
             where T : IHyperbolicFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -12112,7 +12407,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.AsinPi(x)</summary>
-        internal readonly struct AsinPiOperator<T> : IUnaryOperator<T>
+        internal readonly struct AsinPiOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => AsinOperator<T>.Vectorizable;
@@ -12123,7 +12418,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Atan(x)</summary>
-        internal readonly struct AtanOperator<T> : IUnaryOperator<T>
+        internal readonly struct AtanOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -12134,7 +12429,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Atanh(x)</summary>
-        internal readonly struct AtanhOperator<T> : IUnaryOperator<T>
+        internal readonly struct AtanhOperator<T> : IUnaryOperator<T, T>
             where T : IHyperbolicFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -12145,7 +12440,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.AtanPi(x)</summary>
-        internal readonly struct AtanPiOperator<T> : IUnaryOperator<T>
+        internal readonly struct AtanPiOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => AtanOperator<T>.Vectorizable;
@@ -12178,7 +12473,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Cos(x)</summary>
-        internal readonly struct CosOperator<T> : IUnaryOperator<T>
+        internal readonly struct CosOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -12189,7 +12484,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.CosPi(x)</summary>
-        internal readonly struct CosPiOperator<T> : IUnaryOperator<T>
+        internal readonly struct CosPiOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => CosOperator<T>.Vectorizable;
@@ -12200,7 +12495,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Cosh(x)</summary>
-        internal readonly struct CoshOperator<T> : IUnaryOperator<T>
+        internal readonly struct CoshOperator<T> : IUnaryOperator<T, T>
             where T : IHyperbolicFunctions<T>
         {
             // This code is based on `vrs4_coshf` from amd/aocl-libm-ose
@@ -12264,7 +12559,7 @@ public static Vector512<T> Invoke(Vector512<T> t)
         }
 
         /// <summary>T.Sin(x)</summary>
-        internal readonly struct SinOperator<T> : IUnaryOperator<T>
+        internal readonly struct SinOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -12275,7 +12570,7 @@ public static Vector512<T> Invoke(Vector512<T> t)
         }
 
         /// <summary>T.SinPi(x)</summary>
-        internal readonly struct SinPiOperator<T> : IUnaryOperator<T>
+        internal readonly struct SinPiOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => SinOperator<T>.Vectorizable;
@@ -12286,7 +12581,7 @@ public static Vector512<T> Invoke(Vector512<T> t)
         }
 
         /// <summary>T.Sinh(x)</summary>
-        internal readonly struct SinhOperator<T> : IUnaryOperator<T>
+        internal readonly struct SinhOperator<T> : IUnaryOperator<T, T>
             where T : IHyperbolicFunctions<T>
         {
             // Same as cosh, but with `z -` rather than `z +`, and with the sign
@@ -12339,7 +12634,7 @@ public static Vector512<T> Invoke(Vector512<T> t)
         }
 
         /// <summary>T.Tan(x)</summary>
-        internal readonly struct TanOperator<T> : IUnaryOperator<T>
+        internal readonly struct TanOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -12350,7 +12645,7 @@ public static Vector512<T> Invoke(Vector512<T> t)
         }
 
         /// <summary>T.TanPi(x)</summary>
-        internal readonly struct TanPiOperator<T> : IUnaryOperator<T>
+        internal readonly struct TanPiOperator<T> : IUnaryOperator<T, T>
             where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => TanOperator<T>.Vectorizable;
@@ -12361,7 +12656,7 @@ public static Vector512<T> Invoke(Vector512<T> t)
         }
 
         /// <summary>T.Tanh(x)</summary>
-        internal readonly struct TanhOperator<T> : IUnaryOperator<T>
+        internal readonly struct TanhOperator<T> : IUnaryOperator<T, T>
             where T : IHyperbolicFunctions<T>
         {
             // This code is based on `vrs4_tanhf` from amd/aocl-libm-ose
@@ -12424,7 +12719,7 @@ public static Vector512<T> Invoke(Vector512<T> t)
         }
 
         /// <summary>T.Log(x)</summary>
-        internal readonly struct LogOperator<T> : IUnaryOperator<T>
+        internal readonly struct LogOperator<T> : IUnaryOperator<T, T>
             where T : ILogarithmicFunctions<T>
         {
             public static bool Vectorizable => (typeof(T) == typeof(double))
@@ -12510,7 +12805,7 @@ public static Vector512<T> Invoke(Vector512<T> x)
 
 #if !NET9_0_OR_GREATER
         /// <summary>double.Log(x)</summary>
-        internal readonly struct LogOperatorDouble : IUnaryOperator<double>
+        internal readonly struct LogOperatorDouble : IUnaryOperator<double, double>
         {
             // This code is based on `vrd2_log` from amd/aocl-libm-ose
             // Copyright (C) 2018-2020 Advanced Micro Devices, Inc. All rights reserved.
@@ -12816,7 +13111,7 @@ public static Vector512<double> Invoke(Vector512<double> x)
         }
 
         /// <summary>float.Log(x)</summary>
-        internal readonly struct LogOperatorSingle : IUnaryOperator<float>
+        internal readonly struct LogOperatorSingle : IUnaryOperator<float, float>
         {
             // This code is based on `vrs4_logf` from amd/aocl-libm-ose
             // Copyright (C) 2018-2019 Advanced Micro Devices, Inc. All rights reserved.
@@ -13103,7 +13398,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
 #endif
 
         /// <summary>T.Log2(x)</summary>
-        internal readonly struct Log2Operator<T> : IUnaryOperator<T>
+        internal readonly struct Log2Operator<T> : IUnaryOperator<T, T>
             where T : ILogarithmicFunctions<T>
         {
             public static bool Vectorizable => (typeof(T) == typeof(double))
@@ -13189,7 +13484,7 @@ public static Vector512<T> Invoke(Vector512<T> x)
 
 #if !NET9_0_OR_GREATER
         /// <summary>double.Log2(x)</summary>
-        internal readonly struct Log2OperatorDouble : IUnaryOperator<double>
+        internal readonly struct Log2OperatorDouble : IUnaryOperator<double, double>
         {
             // This code is based on `vrd2_log2` from amd/aocl-libm-ose
             // Copyright (C) 2021-2022 Advanced Micro Devices, Inc. All rights reserved.
@@ -13493,7 +13788,7 @@ public static Vector512<double> Invoke(Vector512<double> x)
         }
 
         /// <summary>float.Log2(x)</summary>
-        internal readonly struct Log2OperatorSingle : IUnaryOperator<float>
+        internal readonly struct Log2OperatorSingle : IUnaryOperator<float, float>
         {
             // This code is based on `vrs4_log2f` from amd/aocl-libm-ose
             // Copyright (C) 2021-2022 Advanced Micro Devices, Inc. All rights reserved.
@@ -13775,7 +14070,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
 #endif
 
         /// <summary>T.Log10(x)</summary>
-        internal readonly struct Log10Operator<T> : IUnaryOperator<T>
+        internal readonly struct Log10Operator<T> : IUnaryOperator<T, T>
             where T : ILogarithmicFunctions<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
@@ -13786,7 +14081,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.LogP1(x)</summary>
-        internal readonly struct LogP1Operator<T> : IUnaryOperator<T>
+        internal readonly struct LogP1Operator<T> : IUnaryOperator<T, T>
             where T : ILogarithmicFunctions<T>
         {
             public static bool Vectorizable => LogOperator<T>.Vectorizable;
@@ -13797,7 +14092,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Log2P1(x)</summary>
-        internal readonly struct Log2P1Operator<T> : IUnaryOperator<T>
+        internal readonly struct Log2P1Operator<T> : IUnaryOperator<T, T>
             where T : ILogarithmicFunctions<T>
         {
             public static bool Vectorizable => Log2Operator<T>.Vectorizable;
@@ -13808,7 +14103,7 @@ public static Vector512<float> Invoke(Vector512<float> x)
         }
 
         /// <summary>T.Log10P1(x)</summary>
-        internal readonly struct Log10P1Operator<T> : IUnaryOperator<T>
+        internal readonly struct Log10P1Operator<T> : IUnaryOperator<T, T>
             where T : ILogarithmicFunctions<T>
         {
             public static bool Vectorizable => Log10Operator<T>.Vectorizable;
@@ -13879,7 +14174,7 @@ private static Vector512<T> ElementWiseSelect<T>(Vector512<T> mask, Vector512<T>
         }
 
         /// <summary>1 / (1 + T.Exp(-x))</summary>
-        internal readonly struct SigmoidOperator<T> : IUnaryOperator<T> where T : IExponentialFunctions<T>
+        internal readonly struct SigmoidOperator<T> : IUnaryOperator<T, T> where T : IExponentialFunctions<T>
         {
             public static bool Vectorizable => typeof(T) == typeof(float);
             public static T Invoke(T x) => T.One / (T.One + T.Exp(-x));
@@ -13888,7 +14183,7 @@ 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>
+        internal readonly struct CeilingOperator<T> : IUnaryOperator<T, T> where T : IFloatingPoint<T>
         {
             public static bool Vectorizable => typeof(T) == typeof(float) || typeof(T) == typeof(double);
 
@@ -13940,7 +14235,7 @@ public static Vector512<T> Invoke(Vector512<T> x)
             }
         }
 
-        internal readonly struct FloorOperator<T> : IUnaryOperator<T> where T : IFloatingPoint<T>
+        internal readonly struct FloorOperator<T> : IUnaryOperator<T, T> where T : IFloatingPoint<T>
         {
             public static bool Vectorizable => typeof(T) == typeof(float) || typeof(T) == typeof(double);
 
@@ -13992,7 +14287,7 @@ public static Vector512<T> Invoke(Vector512<T> x)
             }
         }
 
-        private readonly struct TruncateOperator<T> : IUnaryOperator<T> where T : IFloatingPoint<T>
+        private readonly struct TruncateOperator<T> : IUnaryOperator<T, T> where T : IFloatingPoint<T>
         {
             public static bool Vectorizable => typeof(T) == typeof(float) || typeof(T) == typeof(double);
 
@@ -14071,7 +14366,7 @@ public static Vector512<T> Invoke(Vector512<T> x)
         }
 
         /// <summary>T.PopCount(x)</summary>
-        internal readonly struct PopCountOperator<T> : IUnaryOperator<T> where T : IBinaryInteger<T>
+        internal readonly struct PopCountOperator<T> : IUnaryOperator<T, T> where T : IBinaryInteger<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
             public static T Invoke(T x) => T.PopCount(x);
@@ -14081,7 +14376,7 @@ public static Vector512<T> Invoke(Vector512<T> x)
         }
 
         /// <summary>T.LeadingZeroCount(x)</summary>
-        internal readonly struct LeadingZeroCountOperator<T> : IUnaryOperator<T> where T : IBinaryInteger<T>
+        internal readonly struct LeadingZeroCountOperator<T> : IUnaryOperator<T, T> where T : IBinaryInteger<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
             public static T Invoke(T x) => T.LeadingZeroCount(x);
@@ -14091,7 +14386,7 @@ public static Vector512<T> Invoke(Vector512<T> x)
         }
 
         /// <summary>T.TrailingZeroCount(x)</summary>
-        internal readonly struct TrailingZeroCountOperator<T> : IUnaryOperator<T> where T : IBinaryInteger<T>
+        internal readonly struct TrailingZeroCountOperator<T> : IUnaryOperator<T, T> where T : IBinaryInteger<T>
         {
             public static bool Vectorizable => false; // TODO: Vectorize
             public static T Invoke(T x) => T.TrailingZeroCount(x);
@@ -14192,7 +14487,7 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         }
 
         /// <summary>T.DegreesToRadians(x)</summary>
-        internal readonly struct DegreesToRadiansOperator<T> : IUnaryOperator<T> where T : ITrigonometricFunctions<T>
+        internal readonly struct DegreesToRadiansOperator<T> : IUnaryOperator<T, T> where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => true;
             public static T Invoke(T x) => T.DegreesToRadians(x);
@@ -14202,7 +14497,7 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
         }
 
         /// <summary>T.RadiansToDegrees(x)</summary>
-        internal readonly struct RadiansToDegreesOperator<T> : IUnaryOperator<T> where T : ITrigonometricFunctions<T>
+        internal readonly struct RadiansToDegreesOperator<T> : IUnaryOperator<T, T> where T : ITrigonometricFunctions<T>
         {
             public static bool Vectorizable => true;
             public static T Invoke(T x) => T.RadiansToDegrees(x);
@@ -14211,14 +14506,334 @@ public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
             public static Vector512<T> Invoke(Vector512<T> x) => (x * T.CreateChecked(180)) / T.Pi;
         }
 
+        /// <summary>T.ILogB(x)</summary>
+        internal readonly struct ILogBOperator<T> : IUnaryOperator<T, int> where T : IFloatingPointIeee754<T>
+        {
+            public static bool Vectorizable => false; // TODO: vectorize for float
+
+            public static int Invoke(T x) => T.ILogB(x);
+            public static Vector128<int> Invoke(Vector128<T> x) => throw new NotImplementedException();
+            public static Vector256<int> Invoke(Vector256<T> x) => throw new NotImplementedException();
+            public static Vector512<int> Invoke(Vector512<T> x) => throw new NotImplementedException();
+        }
+
+        /// <summary>double.ILogB(x)</summary>
+        internal readonly struct ILogBDoubleOperator : IUnaryTwoToOneOperator<double, int>
+        {
+            public static bool Vectorizable => false; // TODO: vectorize
+
+            public static int Invoke(double x) => double.ILogB(x);
+            public static Vector128<int> Invoke(Vector128<double> lower, Vector128<double> upper) => throw new NotImplementedException();
+            public static Vector256<int> Invoke(Vector256<double> lower, Vector256<double> upper) => throw new NotImplementedException();
+            public static Vector512<int> Invoke(Vector512<double> lower, Vector512<double> upper) => throw new NotImplementedException();
+        }
+
+        /// <summary>T.CreateChecked(x)</summary>
+        internal readonly struct ConvertCheckedFallbackOperator<TFrom, TTo> : IUnaryOperator<TFrom, TTo> where TFrom : INumberBase<TFrom> where TTo : INumberBase<TTo>
+        {
+            public static bool Vectorizable => false;
+
+            public static TTo Invoke(TFrom x) => TTo.CreateChecked(x);
+            public static Vector128<TTo> Invoke(Vector128<TFrom> x) => throw new NotImplementedException();
+            public static Vector256<TTo> Invoke(Vector256<TFrom> x) => throw new NotImplementedException();
+            public static Vector512<TTo> Invoke(Vector512<TFrom> x) => throw new NotImplementedException();
+        }
+
+        /// <summary>T.CreateSaturating(x)</summary>
+        internal readonly struct ConvertSaturatingFallbackOperator<TFrom, TTo> : IUnaryOperator<TFrom, TTo> where TFrom : INumberBase<TFrom> where TTo : INumberBase<TTo>
+        {
+            public static bool Vectorizable => false;
+
+            public static TTo Invoke(TFrom x) => TTo.CreateSaturating(x);
+            public static Vector128<TTo> Invoke(Vector128<TFrom> x) => throw new NotImplementedException();
+            public static Vector256<TTo> Invoke(Vector256<TFrom> x) => throw new NotImplementedException();
+            public static Vector512<TTo> Invoke(Vector512<TFrom> x) => throw new NotImplementedException();
+        }
+
+        /// <summary>T.CreateTruncating(x)</summary>
+        internal readonly struct ConvertTruncatingFallbackOperator<TFrom, TTo> : IUnaryOperator<TFrom, TTo> where TFrom : INumberBase<TFrom> where TTo : INumberBase<TTo>
+        {
+            public static bool Vectorizable => false;
+
+            public static TTo Invoke(TFrom x) => TTo.CreateTruncating(x);
+            public static Vector128<TTo> Invoke(Vector128<TFrom> x) => throw new NotImplementedException();
+            public static Vector256<TTo> Invoke(Vector256<TFrom> x) => throw new NotImplementedException();
+            public static Vector512<TTo> Invoke(Vector512<TFrom> x) => throw new NotImplementedException();
+        }
+
+        /// <summary>(uint)float</summary>
+        internal readonly struct ConvertUInt32ToSingle : IUnaryOperator<uint, float>
+        {
+            public static bool Vectorizable => true;
+
+            public static float Invoke(uint x) => x;
+            public static Vector128<float> Invoke(Vector128<uint> x) => Vector128.ConvertToSingle(x);
+            public static Vector256<float> Invoke(Vector256<uint> x) => Vector256.ConvertToSingle(x);
+            public static Vector512<float> Invoke(Vector512<uint> x) => Vector512.ConvertToSingle(x);
+        }
+
+        /// <summary>(int)float</summary>
+        internal readonly struct ConvertInt32ToSingle : IUnaryOperator<int, float>
+        {
+            public static bool Vectorizable => true;
+
+            public static float Invoke(int x) => x;
+            public static Vector128<float> Invoke(Vector128<int> x) => Vector128.ConvertToSingle(x);
+            public static Vector256<float> Invoke(Vector256<int> x) => Vector256.ConvertToSingle(x);
+            public static Vector512<float> Invoke(Vector512<int> x) => Vector512.ConvertToSingle(x);
+        }
+
+        /// <summary>(float)uint</summary>
+        internal readonly struct ConvertSingleToUInt32 : IUnaryOperator<float, uint>
+        {
+            public static bool Vectorizable => false; // TODO https://github.com/dotnet/runtime/pull/97529: make this true once vectorized behavior matches scalar
+
+            public static uint Invoke(float x) => uint.CreateTruncating(x);
+            public static Vector128<uint> Invoke(Vector128<float> x) => Vector128.ConvertToUInt32(x);
+            public static Vector256<uint> Invoke(Vector256<float> x) => Vector256.ConvertToUInt32(x);
+            public static Vector512<uint> Invoke(Vector512<float> x) => Vector512.ConvertToUInt32(x);
+        }
+
+        /// <summary>(float)int</summary>
+        internal readonly struct ConvertSingleToInt32 : IUnaryOperator<float, int>
+        {
+            public static bool Vectorizable => false; // TODO https://github.com/dotnet/runtime/pull/97529: make this true once vectorized behavior matches scalar
+
+            public static int Invoke(float x) => int.CreateTruncating(x);
+            public static Vector128<int> Invoke(Vector128<float> x) => Vector128.ConvertToInt32(x);
+            public static Vector256<int> Invoke(Vector256<float> x) => Vector256.ConvertToInt32(x);
+            public static Vector512<int> Invoke(Vector512<float> x) => Vector512.ConvertToInt32(x);
+        }
+
+        /// <summary>(double)ulong</summary>
+        internal readonly struct ConvertUInt64ToDouble : IUnaryOperator<ulong, double>
+        {
+            public static bool Vectorizable => true;
+
+            public static double Invoke(ulong x) => x;
+            public static Vector128<double> Invoke(Vector128<ulong> x) => Vector128.ConvertToDouble(x);
+            public static Vector256<double> Invoke(Vector256<ulong> x) => Vector256.ConvertToDouble(x);
+            public static Vector512<double> Invoke(Vector512<ulong> x) => Vector512.ConvertToDouble(x);
+        }
+
+        /// <summary>(double)long</summary>
+        internal readonly struct ConvertInt64ToDouble : IUnaryOperator<long, double>
+        {
+            public static bool Vectorizable => true;
+
+            public static double Invoke(long x) => x;
+            public static Vector128<double> Invoke(Vector128<long> x) => Vector128.ConvertToDouble(x);
+            public static Vector256<double> Invoke(Vector256<long> x) => Vector256.ConvertToDouble(x);
+            public static Vector512<double> Invoke(Vector512<long> x) => Vector512.ConvertToDouble(x);
+        }
+
+        /// <summary>(ulong)double</summary>
+        internal readonly struct ConvertDoubleToUInt64 : IUnaryOperator<double, ulong>
+        {
+            public static bool Vectorizable => false; // TODO https://github.com/dotnet/runtime/pull/97529: make this true once vectorized behavior matches scalar
+
+            public static ulong Invoke(double x) => ulong.CreateTruncating(x);
+            public static Vector128<ulong> Invoke(Vector128<double> x) => Vector128.ConvertToUInt64(x);
+            public static Vector256<ulong> Invoke(Vector256<double> x) => Vector256.ConvertToUInt64(x);
+            public static Vector512<ulong> Invoke(Vector512<double> x) => Vector512.ConvertToUInt64(x);
+        }
+
+        /// <summary>(long)double</summary>
+        internal readonly struct ConvertDoubleToInt64 : IUnaryOperator<double, long>
+        {
+            public static bool Vectorizable => false; // TODO https://github.com/dotnet/runtime/pull/97529: make this true once vectorized behavior matches scalar
+
+            public static long Invoke(double x) => long.CreateTruncating(x);
+            public static Vector128<long> Invoke(Vector128<double> x) => Vector128.ConvertToInt64(x);
+            public static Vector256<long> Invoke(Vector256<double> x) => Vector256.ConvertToInt64(x);
+            public static Vector512<long> Invoke(Vector512<double> x) => Vector512.ConvertToInt64(x);
+        }
+
+        /// <summary>(double)float</summary>
+        internal readonly struct WidenSingleToDoubleOperator : IUnaryOneToTwoOperator<float, double>
+        {
+            public static bool Vectorizable => true;
+
+            public static double Invoke(float x) => x;
+            public static (Vector128<double> Lower, Vector128<double> Upper) Invoke(Vector128<float> x) => Vector128.Widen(x);
+            public static (Vector256<double> Lower, Vector256<double> Upper) Invoke(Vector256<float> x) => Vector256.Widen(x);
+            public static (Vector512<double> Lower, Vector512<double> Upper) Invoke(Vector512<float> x) => Vector512.Widen(x);
+        }
+
+        /// <summary>(float)double</summary>
+        internal readonly struct NarrowDoubleToSingleOperator : IUnaryTwoToOneOperator<double, float>
+        {
+            public static bool Vectorizable => true;
+
+            public static float Invoke(double x) => (float)x;
+            public static Vector128<float> Invoke(Vector128<double> lower, Vector128<double> upper) => Vector128.Narrow(lower, upper);
+            public static Vector256<float> Invoke(Vector256<double> lower, Vector256<double> upper) => Vector256.Narrow(lower, upper);
+            public static Vector512<float> Invoke(Vector512<double> lower, Vector512<double> upper) => Vector512.Narrow(lower, upper);
+        }
+
+        /// <summary>(ushort)byte</summary>
+        internal readonly struct WidenByteToUInt16Operator : IUnaryOneToTwoOperator<byte, ushort>
+        {
+            public static bool Vectorizable => true;
+
+            public static ushort Invoke(byte x) => x;
+            public static (Vector128<ushort> Lower, Vector128<ushort> Upper) Invoke(Vector128<byte> x) => Vector128.Widen(x);
+            public static (Vector256<ushort> Lower, Vector256<ushort> Upper) Invoke(Vector256<byte> x) => Vector256.Widen(x);
+            public static (Vector512<ushort> Lower, Vector512<ushort> Upper) Invoke(Vector512<byte> x) => Vector512.Widen(x);
+        }
+
+        /// <summary>(byte)ushort</summary>
+        internal readonly struct NarrowUInt16ToByteOperator : IUnaryTwoToOneOperator<ushort, byte>
+        {
+            public static bool Vectorizable => true;
+
+            public static byte Invoke(ushort x) => (byte)x;
+            public static Vector128<byte> Invoke(Vector128<ushort> lower, Vector128<ushort> upper) => Vector128.Narrow(lower, upper);
+            public static Vector256<byte> Invoke(Vector256<ushort> lower, Vector256<ushort> upper) => Vector256.Narrow(lower, upper);
+            public static Vector512<byte> Invoke(Vector512<ushort> lower, Vector512<ushort> upper) => Vector512.Narrow(lower, upper);
+        }
+
+        /// <summary>(short)sbyte</summary>
+        internal readonly struct WidenSByteToInt16Operator : IUnaryOneToTwoOperator<sbyte, short>
+        {
+            public static bool Vectorizable => true;
+
+            public static short Invoke(sbyte x) => x;
+            public static (Vector128<short> Lower, Vector128<short> Upper) Invoke(Vector128<sbyte> x) => Vector128.Widen(x);
+            public static (Vector256<short> Lower, Vector256<short> Upper) Invoke(Vector256<sbyte> x) => Vector256.Widen(x);
+            public static (Vector512<short> Lower, Vector512<short> Upper) Invoke(Vector512<sbyte> x) => Vector512.Widen(x);
+        }
+
+        /// <summary>(sbyte)short</summary>
+        internal readonly struct NarrowInt16ToSByteOperator : IUnaryTwoToOneOperator<short, sbyte>
+        {
+            public static bool Vectorizable => true;
+
+            public static sbyte Invoke(short x) => (sbyte)x;
+            public static Vector128<sbyte> Invoke(Vector128<short> lower, Vector128<short> upper) => Vector128.Narrow(lower, upper);
+            public static Vector256<sbyte> Invoke(Vector256<short> lower, Vector256<short> upper) => Vector256.Narrow(lower, upper);
+            public static Vector512<sbyte> Invoke(Vector512<short> lower, Vector512<short> upper) => Vector512.Narrow(lower, upper);
+        }
+
+        /// <summary>(uint)ushort</summary>
+        internal readonly struct WidenUInt16ToUInt32Operator : IUnaryOneToTwoOperator<ushort, uint>
+        {
+            public static bool Vectorizable => true;
+
+            public static uint Invoke(ushort x) => x;
+            public static (Vector128<uint> Lower, Vector128<uint> Upper) Invoke(Vector128<ushort> x) => Vector128.Widen(x);
+            public static (Vector256<uint> Lower, Vector256<uint> Upper) Invoke(Vector256<ushort> x) => Vector256.Widen(x);
+            public static (Vector512<uint> Lower, Vector512<uint> Upper) Invoke(Vector512<ushort> x) => Vector512.Widen(x);
+        }
+
+        /// <summary>(ushort)uint</summary>
+        internal readonly struct NarrowUInt32ToUInt16Operator : IUnaryTwoToOneOperator<uint, ushort>
+        {
+            public static bool Vectorizable => true;
+
+            public static ushort Invoke(uint x) => (ushort)x;
+            public static Vector128<ushort> Invoke(Vector128<uint> lower, Vector128<uint> upper) => Vector128.Narrow(lower, upper);
+            public static Vector256<ushort> Invoke(Vector256<uint> lower, Vector256<uint> upper) => Vector256.Narrow(lower, upper);
+            public static Vector512<ushort> Invoke(Vector512<uint> lower, Vector512<uint> upper) => Vector512.Narrow(lower, upper);
+        }
+
+        /// <summary>(int)short</summary>
+        internal readonly struct WidenInt16ToInt32Operator : IUnaryOneToTwoOperator<short, int>
+        {
+            public static bool Vectorizable => true;
+
+            public static int Invoke(short x) => x;
+            public static (Vector128<int> Lower, Vector128<int> Upper) Invoke(Vector128<short> x) => Vector128.Widen(x);
+            public static (Vector256<int> Lower, Vector256<int> Upper) Invoke(Vector256<short> x) => Vector256.Widen(x);
+            public static (Vector512<int> Lower, Vector512<int> Upper) Invoke(Vector512<short> x) => Vector512.Widen(x);
+        }
+
+        /// <summary>(short)int</summary>
+        internal readonly struct NarrowInt32ToInt16Operator : IUnaryTwoToOneOperator<int, short>
+        {
+            public static bool Vectorizable => true;
+
+            public static short Invoke(int x) => (short)x;
+            public static Vector128<short> Invoke(Vector128<int> lower, Vector128<int> upper) => Vector128.Narrow(lower, upper);
+            public static Vector256<short> Invoke(Vector256<int> lower, Vector256<int> upper) => Vector256.Narrow(lower, upper);
+            public static Vector512<short> Invoke(Vector512<int> lower, Vector512<int> upper) => Vector512.Narrow(lower, upper);
+        }
+
+        /// <summary>(ulong)uint</summary>
+        internal readonly struct WidenUInt32ToUInt64Operator : IUnaryOneToTwoOperator<uint, ulong>
+        {
+            public static bool Vectorizable => true;
+
+            public static ulong Invoke(uint x) => x;
+            public static (Vector128<ulong> Lower, Vector128<ulong> Upper) Invoke(Vector128<uint> x) => Vector128.Widen(x);
+            public static (Vector256<ulong> Lower, Vector256<ulong> Upper) Invoke(Vector256<uint> x) => Vector256.Widen(x);
+            public static (Vector512<ulong> Lower, Vector512<ulong> Upper) Invoke(Vector512<uint> x) => Vector512.Widen(x);
+        }
+
+        /// <summary>(uint)ulong</summary>
+        internal readonly struct NarrowUInt64ToUInt32Operator : IUnaryTwoToOneOperator<ulong, uint>
+        {
+            public static bool Vectorizable => true;
+
+            public static uint Invoke(ulong x) => (uint)x;
+            public static Vector128<uint> Invoke(Vector128<ulong> lower, Vector128<ulong> upper) => Vector128.Narrow(lower, upper);
+            public static Vector256<uint> Invoke(Vector256<ulong> lower, Vector256<ulong> upper) => Vector256.Narrow(lower, upper);
+            public static Vector512<uint> Invoke(Vector512<ulong> lower, Vector512<ulong> upper) => Vector512.Narrow(lower, upper);
+        }
+
+        /// <summary>(long)int</summary>
+        internal readonly struct WidenInt32ToInt64Operator : IUnaryOneToTwoOperator<int, long>
+        {
+            public static bool Vectorizable => true;
+
+            public static long Invoke(int x) => x;
+            public static (Vector128<long> Lower, Vector128<long> Upper) Invoke(Vector128<int> x) => Vector128.Widen(x);
+            public static (Vector256<long> Lower, Vector256<long> Upper) Invoke(Vector256<int> x) => Vector256.Widen(x);
+            public static (Vector512<long> Lower, Vector512<long> Upper) Invoke(Vector512<int> x) => Vector512.Widen(x);
+        }
+
+        /// <summary>(int)long</summary>
+        internal readonly struct NarrowInt64ToInt32Operator : IUnaryTwoToOneOperator<long, int>
+        {
+            public static bool Vectorizable => true;
+
+            public static int Invoke(long x) => (int)x;
+            public static Vector128<int> Invoke(Vector128<long> lower, Vector128<long> upper) => Vector128.Narrow(lower, upper);
+            public static Vector256<int> Invoke(Vector256<long> lower, Vector256<long> upper) => Vector256.Narrow(lower, upper);
+            public static Vector512<int> Invoke(Vector512<long> lower, Vector512<long> upper) => Vector512.Narrow(lower, upper);
+        }
+
+        /// <summary>Operator that takes one input value and returns a single value.</summary>
+        /// <remarks>The input and output type must be of the same size if vectorization is desired.</remarks>
+        private interface IUnaryOperator<TInput, TOutput>
+        {
+            static abstract bool Vectorizable { get; }
+            static abstract TOutput Invoke(TInput x);
+            static abstract Vector128<TOutput> Invoke(Vector128<TInput> x);
+            static abstract Vector256<TOutput> Invoke(Vector256<TInput> x);
+            static abstract Vector512<TOutput> Invoke(Vector512<TInput> x);
+        }
+
+        /// <summary>Operator that takes one input value and returns a single value.</summary>
+        /// <remarks>The input type must be half the size of the output type.</remarks>
+        private interface IUnaryOneToTwoOperator<TInput, TOutput>
+        {
+            static abstract bool Vectorizable { get; }
+            static abstract TOutput Invoke(TInput x);
+            static abstract (Vector128<TOutput> Lower, Vector128<TOutput> Upper) Invoke(Vector128<TInput> x);
+            static abstract (Vector256<TOutput> Lower, Vector256<TOutput> Upper) Invoke(Vector256<TInput> x);
+            static abstract (Vector512<TOutput> Lower, Vector512<TOutput> Upper) Invoke(Vector512<TInput> x);
+        }
+
         /// <summary>Operator that takes one input value and returns a single value.</summary>
-        private interface IUnaryOperator<T>
+        /// <remarks>The input type must be twice the size of the output type.</remarks>
+        private interface IUnaryTwoToOneOperator<TInput, TOutput>
         {
             static abstract bool Vectorizable { get; }
-            static abstract T Invoke(T x);
-            static abstract Vector128<T> Invoke(Vector128<T> x);
-            static abstract Vector256<T> Invoke(Vector256<T> x);
-            static abstract Vector512<T> Invoke(Vector512<T> x);
+            static abstract TOutput Invoke(TInput x);
+            static abstract Vector128<TOutput> Invoke(Vector128<TInput> lower, Vector128<TInput> upper);
+            static abstract Vector256<TOutput> Invoke(Vector256<TInput> lower, Vector256<TInput> upper);
+            static abstract Vector512<TOutput> Invoke(Vector512<TInput> lower, Vector512<TInput> upper);
         }
 
         /// <summary>Operator that takes two input values and returns a single value.</summary>
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
index b44036b1a74628..4d1c22a402e54e 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
@@ -4,6 +4,7 @@
 using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Runtime.InteropServices;
 using Xunit;
 using Xunit.Sdk;
@@ -15,6 +16,198 @@
 
 namespace System.Numerics.Tensors.Tests
 {
+    public class ConvertTests
+    {
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBuiltWithAggressiveTrimming))]
+        public void ConvertTruncatingAndSaturating()
+        {
+            MethodInfo convertTruncatingImpl = typeof(ConvertTests).GetMethod(nameof(ConvertTruncatingImpl), BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
+            Assert.NotNull(convertTruncatingImpl);
+
+            MethodInfo convertSaturatingImpl = typeof(ConvertTests).GetMethod(nameof(ConvertSaturatingImpl), BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
+            Assert.NotNull(convertSaturatingImpl);
+
+            Type[] types =
+            [
+                typeof(sbyte), typeof(byte),
+                typeof(short), typeof(ushort), typeof(char),
+                typeof(int), typeof(uint),
+                typeof(long), typeof(ulong),
+                typeof(nint), typeof(nuint),
+                typeof(Half), typeof(float), typeof(double), typeof(NFloat),
+                typeof(Int128), typeof(UInt128),
+            ];
+
+            foreach (Type from in types)
+            {
+                foreach (Type to in types)
+                {
+                    convertTruncatingImpl.MakeGenericMethod(from, to).Invoke(null, null);
+                    convertSaturatingImpl.MakeGenericMethod(from, to).Invoke(null, null);
+                }
+            }
+        }
+
+        [Fact]
+        public void ConvertChecked()
+        {
+            // Conversions that never overflow. This isn't an exhaustive list; just a sampling.
+            ConvertCheckedImpl<byte, byte>();
+            ConvertCheckedImpl<byte, ushort>();
+            ConvertCheckedImpl<byte, short>();
+            ConvertCheckedImpl<byte, uint>();
+            ConvertCheckedImpl<byte, int>();
+            ConvertCheckedImpl<byte, ulong>();
+            ConvertCheckedImpl<byte, long>();
+            ConvertCheckedImpl<byte, float>();
+            ConvertCheckedImpl<Half, Half>();
+            ConvertCheckedImpl<Half, float>();
+            ConvertCheckedImpl<Half, double>();
+            ConvertCheckedImpl<float, double>();
+            ConvertCheckedImpl<double, float>();
+
+            // Conversions that may overflow. This isn't an exhaustive list; just a sampling.
+            ConvertCheckedImpl<float, int>(42f, float.MaxValue);
+            ConvertCheckedImpl<long, int>(42, int.MaxValue + 1L);
+        }
+
+        private static void ConvertTruncatingImpl<TFrom, TTo>()
+            where TFrom : unmanaged, INumber<TFrom>
+            where TTo : unmanaged, INumber<TTo>
+        {
+            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.ConvertTruncating<TFrom, TTo>(new TFrom[3], new TTo[2]));
+
+            foreach (int tensorLength in Helpers.TensorLengthsIncluding0)
+            {
+                using BoundedMemory<TFrom> source = BoundedMemory.Allocate<TFrom>(tensorLength);
+                using BoundedMemory<TTo> destination = BoundedMemory.Allocate<TTo>(tensorLength);
+
+                Random rand = new(42);
+                Span<TFrom> sourceSpan = source.Span;
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    sourceSpan[i] = TFrom.CreateTruncating(new Int128(
+                        (ulong)rand.NextInt64(long.MinValue, long.MaxValue),
+                        (ulong)rand.NextInt64(long.MinValue, long.MaxValue)));
+                }
+
+                TensorPrimitives.ConvertTruncating<TFrom, TTo>(source.Span, destination.Span);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    if (!IsEqualWithTolerance(TTo.CreateTruncating(source.Span[i]), destination.Span[i]))
+                    {
+                        throw new XunitException($"{typeof(TFrom).Name} => {typeof(TTo).Name}. Input: {source.Span[i]}. Actual: {destination.Span[i]}. Expected: {TTo.CreateTruncating(source.Span[i])}.");
+                    }
+                }
+            };
+        }
+
+        private static void ConvertSaturatingImpl<TFrom, TTo>()
+            where TFrom : unmanaged, INumber<TFrom>
+            where TTo : unmanaged, INumber<TTo>
+        {
+            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.ConvertSaturating<TFrom, TTo>(new TFrom[3], new TTo[2]));
+
+            foreach (int tensorLength in Helpers.TensorLengthsIncluding0)
+            {
+                using BoundedMemory<TFrom> source = BoundedMemory.Allocate<TFrom>(tensorLength);
+                using BoundedMemory<TTo> destination = BoundedMemory.Allocate<TTo>(tensorLength);
+
+                Random rand = new(42);
+                Span<TFrom> sourceSpan = source.Span;
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    sourceSpan[i] = TFrom.CreateTruncating(new Int128(
+                        (ulong)rand.NextInt64(long.MinValue, long.MaxValue),
+                        (ulong)rand.NextInt64(long.MinValue, long.MaxValue)));
+                }
+
+                TensorPrimitives.ConvertSaturating<TFrom, TTo>(source.Span, destination.Span);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    if (!IsEqualWithTolerance(TTo.CreateSaturating(source.Span[i]), destination.Span[i]))
+                    {
+                        throw new XunitException($"{typeof(TFrom).Name} => {typeof(TTo).Name}. Input: {source.Span[i]}. Actual: {destination.Span[i]}. Expected: {TTo.CreateSaturating(source.Span[i])}.");
+                    }
+                }
+            };
+        }
+
+        private static void ConvertCheckedImpl<TFrom, TTo>()
+            where TFrom : unmanaged, INumber<TFrom>
+            where TTo : unmanaged, INumber<TTo>
+        {
+            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.ConvertChecked<TFrom, TTo>(new TFrom[3], new TTo[2]));
+
+            foreach (int tensorLength in Helpers.TensorLengthsIncluding0)
+            {
+                using BoundedMemory<TFrom> source = BoundedMemory.Allocate<TFrom>(tensorLength);
+                using BoundedMemory<TTo> destination = BoundedMemory.Allocate<TTo>(tensorLength);
+
+                Random rand = new(42);
+                Span<TFrom> sourceSpan = source.Span;
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    sourceSpan[i] = TFrom.CreateTruncating(new Int128(
+                        (ulong)rand.NextInt64(long.MinValue, long.MaxValue),
+                        (ulong)rand.NextInt64(long.MinValue, long.MaxValue)));
+                }
+
+                TensorPrimitives.ConvertChecked<TFrom, TTo>(source.Span, destination.Span);
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    if (!IsEqualWithTolerance(TTo.CreateChecked(source.Span[i]), destination.Span[i]))
+                    {
+                        throw new XunitException($"{typeof(TFrom).Name} => {typeof(TTo).Name}. Input: {source.Span[i]}. Actual: {destination.Span[i]}. Expected: {TTo.CreateChecked(source.Span[i])}.");
+                    }
+                }
+            };
+        }
+
+        private static void ConvertCheckedImpl<TFrom, TTo>(TFrom valid, TFrom invalid)
+            where TFrom : unmanaged, INumber<TFrom>
+            where TTo : unmanaged, INumber<TTo>
+        {
+            foreach (int tensorLength in Helpers.TensorLengths)
+            {
+                using BoundedMemory<TFrom> source = BoundedMemory.Allocate<TFrom>(tensorLength);
+                using BoundedMemory<TTo> destination = BoundedMemory.Allocate<TTo>(tensorLength);
+
+                // Test with valid
+                source.Span.Fill(valid);
+                TensorPrimitives.ConvertChecked<TFrom, TTo>(source.Span, destination.Span);
+                foreach (TTo result in destination.Span)
+                {
+                    Assert.True(IsEqualWithTolerance(TTo.CreateChecked(valid), result));
+                }
+
+                // Test with at least one invalid
+                foreach (int invalidPosition in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    source.Span.Fill(valid);
+                    source.Span[invalidPosition] = invalid;
+                    Assert.Throws<OverflowException>(() => TensorPrimitives.ConvertChecked<TFrom, TTo>(source.Span, destination.Span));
+                }
+            };
+        }
+
+        private static bool IsEqualWithTolerance<T>(T expected, T actual, T? tolerance = null) where T : unmanaged, INumber<T>
+        {
+            tolerance ??= T.CreateTruncating(0.0001);
+
+            T diff = T.Abs(expected - actual);
+            if (diff > tolerance && diff > T.Max(T.Abs(expected), T.Abs(actual)) * tolerance)
+            {
+                return false;
+            }
+
+            return true;
+        }
+    }
+
     public class DoubleGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<double> { }
     public class SingleGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<float> { }
     public class HalfGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<Half>