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 1cde4351546b26..da348aca973905 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
@@ -8,7 +8,49 @@ namespace System.Numerics.Tensors
 {
     public static partial class TensorPrimitives
     {
+        public static void Abs<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
+        public static void AddMultiply<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.ReadOnlySpan<T> multiplier, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
+        public static void AddMultiply<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, T multiplier, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
+        public static void AddMultiply<T>(System.ReadOnlySpan<T> x, T y, System.ReadOnlySpan<T> multiplier, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
+        public static void Add<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { }
+        public static void Add<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { }
         public static void ConvertToHalf(System.ReadOnlySpan<float> source, System.Span<System.Half> destination) { throw null; }
         public static void ConvertToSingle(System.ReadOnlySpan<System.Half> source, System.Span<float> destination) { throw null; }
+        public static void Cosh<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IHyperbolicFunctions<T> { }
+        public static T CosineSimilarity<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y) where T : System.Numerics.IRootFunctions<T> { throw null; }
+        public static T Distance<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y) where T : System.Numerics.IRootFunctions<T> { throw null; }
+        public static void Divide<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IDivisionOperators<T, T, T> { }
+        public static void Divide<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.IDivisionOperators<T, T, T> { }
+        public static T Dot<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
+        public static void Exp<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IExponentialFunctions<T> { }
+        public static void Log2<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ILogarithmicFunctions<T> { }
+        public static void Log<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.ILogarithmicFunctions<T> { }
+        public static T MaxMagnitude<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumberBase<T> { throw null; }
+        public static void MaxMagnitude<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
+        public static T Max<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
+        public static void Max<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.INumber<T> { }
+        public static T MinMagnitude<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumberBase<T> { throw null; }
+        public static void MinMagnitude<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.INumberBase<T> { }
+        public static T Min<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
+        public static void Min<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.INumber<T> { }
+        public static void MultiplyAdd<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.ReadOnlySpan<T> addend, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
+        public static void MultiplyAdd<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, T addend, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
+        public static void MultiplyAdd<T>(System.ReadOnlySpan<T> x, T y, System.ReadOnlySpan<T> addend, System.Span<T> destination) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T> { }
+        public static void Multiply<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { }
+        public static void Multiply<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { }
+        public static void Negate<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IUnaryNegationOperators<T, T> { }
+        public static T Norm<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.IRootFunctions<T> { throw null; }
+        public static T ProductOfDifferences<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y) where T : System.Numerics.ISubtractionOperators<T, T, T>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
+        public static T ProductOfSums<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
+        public static T Product<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
+        public static void Sigmoid<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IExponentialFunctions<T> { }
+        public static void Sinh<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IHyperbolicFunctions<T> { }
+        public static void SoftMax<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IExponentialFunctions<T> { }
+        public static void Subtract<T>(System.ReadOnlySpan<T> x, System.ReadOnlySpan<T> y, System.Span<T> destination) where T : System.Numerics.ISubtractionOperators<T, T, T> { }
+        public static void Subtract<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destination) where T : System.Numerics.ISubtractionOperators<T, T, T> { }
+        public static T SumOfMagnitudes<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.INumberBase<T> { throw null; }
+        public static T SumOfSquares<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T>, System.Numerics.IMultiplyOperators<T, T, T> { throw null; }
+        public static T Sum<T>(System.ReadOnlySpan<T> x) where T : System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
+        public static void Tanh<T>(System.ReadOnlySpan<T> x, System.Span<T> destination) where T : System.Numerics.IHyperbolicFunctions<T> { }
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx b/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
index 86b9f4d82b1f61..def219f3544820 100644
--- a/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
+++ b/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
@@ -129,4 +129,7 @@
   <data name="Argument_InputAndDestinationSpanMustNotOverlap" xml:space="preserve">
     <value>The destination span may only overlap with an input span if the two spans start at the same memory location.</value>
   </data>
+  <data name="Overflow_NegateTwosCompNum" xml:space="preserve">
+    <value>Negating the minimum value of a twos complement number is invalid.</value>
+  </data>
 </root>
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index cb1e66fdea1c06..ae18ca1b2d9398 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -9,16 +9,19 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <Compile Include="System\Numerics\Tensors\TensorPrimitives.cs" />
+    <Compile Include="System\Numerics\Tensors\TensorPrimitives.Single.cs" />
+    <Compile Include="System\Numerics\Tensors\TensorPrimitives.Helpers.cs" />
     <Compile Include="System\ThrowHelper.cs" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
-    <Compile Include="System\Numerics\Tensors\TensorPrimitives.netcore.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Single.netcore.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.T.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.netcore.cs" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
-    <Compile Include="System\Numerics\Tensors\TensorPrimitives.netstandard.cs" />
+    <Compile Include="System\Numerics\Tensors\netstandard\TensorPrimitives.Single.netstandard.cs" />
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
     <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.Numerics\src\Microsoft.Bcl.Numerics.csproj" />
   </ItemGroup>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Helpers.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Helpers.cs
new file mode 100644
index 00000000000000..4b5f40cec39d0f
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Helpers.cs
@@ -0,0 +1,384 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace System.Numerics.Tensors
+{
+    /// <summary>Performs primitive tensor operations over spans of memory.</summary>
+    public static partial class TensorPrimitives
+    {
+        /// <summary>Throws an exception if the <paramref name="input"/> and <paramref name="output"/> spans overlap and don't begin at the same memory location.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void ValidateInputOutputSpanNonOverlapping<T>(ReadOnlySpan<T> input, Span<T> output)
+        {
+            if (!Unsafe.AreSame(ref MemoryMarshal.GetReference(input), ref MemoryMarshal.GetReference(output)) &&
+                input.Overlaps(output))
+            {
+                ThrowHelper.ThrowArgument_InputAndDestinationSpanMustNotOverlap();
+            }
+        }
+
+        /// <summary>Throws an <see cref="OverflowException"/> for trying to negate the minimum value of a two-complement value.</summary>
+        internal static void ThrowNegateTwosCompOverflow() => throw new OverflowException(SR.Overflow_NegateTwosCompNum);
+
+        /// <summary>Mask used to handle alignment elements before vectorized handling of the input.</summary>
+        /// <remarks>
+        /// Logically 64 rows of 64 bytes. The Nth row should be used to handle N alignment elements at the
+        /// beginning of the input, where elements in the vector after that will be zero'd.
+        ///
+        /// There actually exists 65 rows in the table with the last row being a repeat of the first. This is
+        /// done because it allows the main algorithms to use a simplified algorithm when computing the amount
+        /// of misalignment where we always skip the first 64 elements, even if already aligned, so we don't
+        /// double process them. This allows us to avoid an additional branch.
+        /// </remarks>
+        private static ReadOnlySpan<byte> AlignmentByteMask_64x65 =>
+        [
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+        ];
+
+        /// <summary>Mask used to handle alignment elements before vectorized handling of the input.</summary>
+        /// <remarks>
+        /// Logically 32 rows of 32 uints. The Nth row should be used to handle N alignment elements at the
+        /// beginning of the input, where elements in the vector after that will be zero'd.
+        ///
+        /// There actually exists 33 rows in the table with the last row being a repeat of the first. This is
+        /// done because it allows the main algorithms to use a simplified algorithm when computing the amount
+        /// of misalignment where we always skip the first 32 elements, even if already aligned, so we don't
+        /// double process them. This allows us to avoid an additional branch.
+        /// </remarks>
+        private static ReadOnlySpan<ushort> AlignmentUInt16Mask_32x33 =>
+        [
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000,
+            0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+        ];
+
+        /// <summary>Mask used to handle alignment elements before vectorized handling of the input.</summary>
+        /// <remarks>
+        /// Logically 16 rows of 16 uints. The Nth row should be used to handle N alignment elements at the
+        /// beginning of the input, where elements in the vector after that will be zero'd.
+        ///
+        /// There actually exists 17 rows in the table with the last row being a repeat of the first. This is
+        /// done because it allows the main algorithms to use a simplified algorithm when computing the amount
+        /// of misalignment where we always skip the first 16 elements, even if already aligned, so we don't
+        /// double process them. This allows us to avoid an additional branch.
+        /// </remarks>
+        private static ReadOnlySpan<uint> AlignmentUInt32Mask_16x17 =>
+        [
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000,
+            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+        ];
+
+        /// <summary>Mask used to handle alignment elements before vectorized handling of the input.</summary>
+        /// <remarks>
+        /// Logically 8 rows of 8 ulongs. The Nth row should be used to handle N alignment elements at the
+        /// beginning of the input, where elements in the vector after that will be zero'd.
+        ///
+        /// There actually exists 9 rows in the table with the last row being a repeat of the first. This is
+        /// done because it allows the main algorithms to use a simplified algorithm when computing the amount
+        /// of misalignment where we always skip the first 8 elements, even if already aligned, so we don't
+        /// double process them. This allows us to avoid an additional branch.
+        /// </remarks>
+        private static ReadOnlySpan<ulong> AlignmentUInt64Mask_8x9 =>
+        [
+            0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
+            0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+            0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+            0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+            0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+            0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+            0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000, 0x0000000000000000,
+            0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0x0000000000000000,
+            0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
+        ];
+
+        /// <summary>Mask used to handle remaining elements after vectorized handling of the input.</summary>
+        /// <remarks>
+        /// Logically 64 rows of 64 ushorts. The Nth row should be used to handle N remaining elements at the
+        /// end of the input, where elements in the vector prior to that will be zero'd.
+        ///
+        /// Much as with the AlignmentMask table, we actually have 65 rows where the last row is a repeat of
+        /// the first. Doing this allows us to avoid an additional branch and instead to always process the
+        /// last 16 elements via a conditional select instead.
+        /// </remarks>
+        private static ReadOnlySpan<byte> RemainderByteMask_64x65 =>
+        [
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ];
+
+        /// <summary>Mask used to handle remaining elements after vectorized handling of the input.</summary>
+        /// <remarks>
+        /// Logically 32 rows of 32 ushorts. The Nth row should be used to handle N remaining elements at the
+        /// end of the input, where elements in the vector prior to that will be zero'd.
+        ///
+        /// Much as with the AlignmentMask table, we actually have 33 rows where the last row is a repeat of
+        /// the first. Doing this allows us to avoid an additional branch and instead to always process the
+        /// last 16 elements via a conditional select instead.
+        /// </remarks>
+        private static ReadOnlySpan<ushort> RemainderUInt16Mask_32x33 =>
+        [
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
+            0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+        ];
+
+        /// <summary>Mask used to handle remaining elements after vectorized handling of the input.</summary>
+        /// <remarks>
+        /// Logically 16 rows of 16 uints. The Nth row should be used to handle N remaining elements at the
+        /// end of the input, where elements in the vector prior to that will be zero'd.
+        ///
+        /// Much as with the AlignmentMask table, we actually have 17 rows where the last row is a repeat of
+        /// the first. Doing this allows us to avoid an additional branch and instead to always process the
+        /// last 16 elements via a conditional select instead.
+        /// </remarks>
+        private static ReadOnlySpan<uint> RemainderUInt32Mask_16x17 =>
+        [
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        ];
+
+        /// <summary>Mask used to handle remaining elements after vectorized handling of the input.</summary>
+        /// <remarks>
+        /// Logically 8 rows of 8 ulongs. The Nth row should be used to handle N remaining elements at the
+        /// end of the input, where elements in the vector prior to that will be zero'd.
+        ///
+        /// Much as with the AlignmentMask table, we actually have 9 rows where the last row is a repeat of
+        /// the first. Doing this allows us to avoid an additional branch and instead to always process the
+        /// last 8 elements via a conditional select instead.
+        /// </remarks>
+        private static ReadOnlySpan<ulong> RemainderUInt64Mask_8x9 =>
+        [
+            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF,
+            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
+            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
+            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
+            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
+            0x0000000000000000, 0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
+            0x0000000000000000, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
+            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+        ];
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Single.cs
similarity index 84%
rename from src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.cs
rename to src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Single.cs
index 88094042e62c9f..0ad05d15286d97 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Single.cs
@@ -27,7 +27,7 @@ public static partial class TensorPrimitives
         /// </para>
         /// </remarks>
         public static void Abs(ReadOnlySpan<float> x, Span<float> destination) =>
-            InvokeSpanIntoSpan<AbsoluteOperator>(x, destination);
+            InvokeSpanIntoSpan<AbsoluteOperator_Single>(x, destination);
 
         /// <summary>Computes the element-wise addition of single-precision floating-point numbers in the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -46,7 +46,7 @@ public static void Abs(ReadOnlySpan<float> x, Span<float> destination) =>
         /// </para>
         /// </remarks>
         public static void Add(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) =>
-            InvokeSpanSpanIntoSpan<AddOperator>(x, y, destination);
+            InvokeSpanSpanIntoSpan<AddOperator_Single>(x, y, destination);
 
         /// <summary>Computes the element-wise addition of single-precision floating-point numbers in the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -63,7 +63,7 @@ public static void Add(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float>
         /// </para>
         /// </remarks>
         public static void Add(ReadOnlySpan<float> x, float y, Span<float> destination) =>
-            InvokeSpanScalarIntoSpan<AddOperator>(x, y, destination);
+            InvokeSpanScalarIntoSpan<AddOperator_Single>(x, y, destination);
 
         /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -84,7 +84,7 @@ public static void Add(ReadOnlySpan<float> x, float y, Span<float> destination)
         /// </para>
         /// </remarks>
         public static void AddMultiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, ReadOnlySpan<float> multiplier, Span<float> destination) =>
-            InvokeSpanSpanSpanIntoSpan<AddMultiplyOperator>(x, y, multiplier, destination);
+            InvokeSpanSpanSpanIntoSpan<AddMultiplyOperator_Single>(x, y, multiplier, destination);
 
         /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -104,7 +104,7 @@ public static void AddMultiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Rea
         /// </para>
         /// </remarks>
         public static void AddMultiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, float multiplier, Span<float> destination) =>
-            InvokeSpanSpanScalarIntoSpan<AddMultiplyOperator>(x, y, multiplier, destination);
+            InvokeSpanSpanScalarIntoSpan<AddMultiplyOperator_Single>(x, y, multiplier, destination);
 
         /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -124,7 +124,7 @@ public static void AddMultiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, flo
         /// </para>
         /// </remarks>
         public static void AddMultiply(ReadOnlySpan<float> x, float y, ReadOnlySpan<float> multiplier, Span<float> destination) =>
-            InvokeSpanScalarSpanIntoSpan<AddMultiplyOperator>(x, y, multiplier, destination);
+            InvokeSpanScalarSpanIntoSpan<AddMultiplyOperator_Single>(x, y, multiplier, destination);
 
         /// <summary>Computes the element-wise hyperbolic cosine of each single-precision floating-point radian angle in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -148,7 +148,7 @@ public static void AddMultiply(ReadOnlySpan<float> x, float y, ReadOnlySpan<floa
         /// </para>
         /// </remarks>
         public static void Cosh(ReadOnlySpan<float> x, Span<float> destination) =>
-            InvokeSpanIntoSpan<CoshOperator>(x, destination);
+            InvokeSpanIntoSpan<CoshOperator_Single>(x, destination);
 
         /// <summary>Computes the cosine similarity between the two specified non-empty, equal-length tensors of single-precision floating-point numbers.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -203,7 +203,7 @@ public static float Distance(ReadOnlySpan<float> x, ReadOnlySpan<float> y)
                 ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
             }
 
-            return MathF.Sqrt(Aggregate<SubtractSquaredOperator, AddOperator>(x, y));
+            return MathF.Sqrt(Aggregate<SubtractSquaredOperator_Single, AddOperator_Single>(x, y));
         }
 
         /// <summary>Computes the element-wise division of single-precision floating-point numbers in the specified tensors.</summary>
@@ -223,7 +223,7 @@ public static float Distance(ReadOnlySpan<float> x, ReadOnlySpan<float> y)
         /// </para>
         /// </remarks>
         public static void Divide(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) =>
-            InvokeSpanSpanIntoSpan<DivideOperator>(x, y, destination);
+            InvokeSpanSpanIntoSpan<DivideOperator_Single>(x, y, destination);
 
         /// <summary>Computes the element-wise division of single-precision floating-point numbers in the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -240,7 +240,7 @@ public static void Divide(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<flo
         /// </para>
         /// </remarks>
         public static void Divide(ReadOnlySpan<float> x, float y, Span<float> destination) =>
-            InvokeSpanScalarIntoSpan<DivideOperator>(x, y, destination);
+            InvokeSpanScalarIntoSpan<DivideOperator_Single>(x, y, destination);
 
         /// <summary>Computes the dot product of two tensors containing single-precision floating-point numbers.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -266,7 +266,7 @@ public static void Divide(ReadOnlySpan<float> x, float y, Span<float> destinatio
         /// </para>
         /// </remarks>
         public static float Dot(ReadOnlySpan<float> x, ReadOnlySpan<float> y) =>
-            Aggregate<MultiplyOperator, AddOperator>(x, y);
+            Aggregate<MultiplyOperator_Single, AddOperator_Single>(x, y);
 
         /// <summary>Computes the element-wise result of raising <c>e</c> to the single-precision floating-point number powers in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -287,7 +287,7 @@ public static float Dot(ReadOnlySpan<float> x, ReadOnlySpan<float> y) =>
         /// </para>
         /// </remarks>
         public static void Exp(ReadOnlySpan<float> x, Span<float> destination) =>
-            InvokeSpanIntoSpan<ExpOperator>(x, destination);
+            InvokeSpanIntoSpan<ExpOperator_Single>(x, destination);
 
         /// <summary>Searches for the index of the largest single-precision floating-point number in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -303,7 +303,7 @@ public static void Exp(ReadOnlySpan<float> x, Span<float> destination) =>
         /// </para>
         /// </remarks>
         public static int IndexOfMax(ReadOnlySpan<float> x) =>
-            IndexOfMinMaxCore<IndexOfMaxOperator>(x);
+            IndexOfMinMaxCore<IndexOfMaxOperator_Single>(x);
 
         /// <summary>Searches for the index of the single-precision floating-point number with the largest magnitude in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -320,7 +320,7 @@ public static int IndexOfMax(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static int IndexOfMaxMagnitude(ReadOnlySpan<float> x) =>
-            IndexOfMinMaxCore<IndexOfMaxMagnitudeOperator>(x);
+            IndexOfMinMaxCore<IndexOfMaxMagnitudeOperator_Single>(x);
 
         /// <summary>Searches for the index of the smallest single-precision floating-point number in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -336,7 +336,7 @@ public static int IndexOfMaxMagnitude(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static int IndexOfMin(ReadOnlySpan<float> x) =>
-            IndexOfMinMaxCore<IndexOfMinOperator>(x);
+            IndexOfMinMaxCore<IndexOfMinOperator_Single>(x);
 
         /// <summary>Searches for the index of the single-precision floating-point number with the smallest magnitude in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -353,7 +353,7 @@ public static int IndexOfMin(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static int IndexOfMinMagnitude(ReadOnlySpan<float> x) =>
-            IndexOfMinMaxCore<IndexOfMinMagnitudeOperator>(x);
+            IndexOfMinMaxCore<IndexOfMinMagnitudeOperator_Single>(x);
 
         /// <summary>Computes the element-wise natural (base <c>e</c>) logarithm of single-precision floating-point numbers in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -376,7 +376,7 @@ public static int IndexOfMinMagnitude(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static void Log(ReadOnlySpan<float> x, Span<float> destination) =>
-            InvokeSpanIntoSpan<LogOperator>(x, destination);
+            InvokeSpanIntoSpan<LogOperator_Single>(x, destination);
 
         /// <summary>Computes the element-wise base 2 logarithm of single-precision floating-point numbers in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -399,7 +399,7 @@ public static void Log(ReadOnlySpan<float> x, Span<float> destination) =>
         /// </para>
         /// </remarks>
         public static void Log2(ReadOnlySpan<float> x, Span<float> destination) =>
-            InvokeSpanIntoSpan<Log2Operator>(x, destination);
+            InvokeSpanIntoSpan<Log2Operator_Single>(x, destination);
 
         /// <summary>Searches for the largest single-precision floating-point number in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -416,7 +416,7 @@ public static void Log2(ReadOnlySpan<float> x, Span<float> destination) =>
         /// </para>
         /// </remarks>
         public static float Max(ReadOnlySpan<float> x) =>
-            MinMaxCore<MaxOperator>(x);
+            MinMaxCore<MaxOperator_Single>(x);
 
         /// <summary>Computes the element-wise maximum of the single-precision floating-point numbers in the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -440,7 +440,7 @@ public static float Max(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static void Max(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) =>
-            InvokeSpanSpanIntoSpan<MaxPropagateNaNOperator>(x, y, destination);
+            InvokeSpanSpanIntoSpan<MaxPropagateNaNOperator_Single>(x, y, destination);
 
         /// <summary>Searches for the single-precision floating-point number with the largest magnitude in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -458,7 +458,7 @@ public static void Max(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float>
         /// </para>
         /// </remarks>
         public static float MaxMagnitude(ReadOnlySpan<float> x) =>
-            MinMaxCore<MaxMagnitudeOperator>(x);
+            MinMaxCore<MaxMagnitudeOperator_Single>(x);
 
         /// <summary>Computes the element-wise single-precision floating-point number with the largest magnitude in the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -476,7 +476,7 @@ public static float MaxMagnitude(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static void MaxMagnitude(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) =>
-            InvokeSpanSpanIntoSpan<MaxMagnitudePropagateNaNOperator>(x, y, destination);
+            InvokeSpanSpanIntoSpan<MaxMagnitudePropagateNaNOperator_Single>(x, y, destination);
 
         /// <summary>Searches for the smallest single-precision floating-point number in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -493,7 +493,7 @@ public static void MaxMagnitude(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Sp
         /// </para>
         /// </remarks>
         public static float Min(ReadOnlySpan<float> x) =>
-            MinMaxCore<MinOperator>(x);
+            MinMaxCore<MinOperator_Single>(x);
 
         /// <summary>Computes the element-wise minimum of the single-precision floating-point numbers in the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -517,7 +517,7 @@ public static float Min(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static void Min(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) =>
-            InvokeSpanSpanIntoSpan<MinPropagateNaNOperator>(x, y, destination);
+            InvokeSpanSpanIntoSpan<MinPropagateNaNOperator_Single>(x, y, destination);
 
         /// <summary>Searches for the single-precision floating-point number with the smallest magnitude in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -535,7 +535,7 @@ public static void Min(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float>
         /// </para>
         /// </remarks>
         public static float MinMagnitude(ReadOnlySpan<float> x) =>
-            MinMaxCore<MinMagnitudeOperator>(x);
+            MinMaxCore<MinMagnitudeOperator_Single>(x);
 
         /// <summary>Computes the element-wise single-precision floating-point number with the smallest magnitude in the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -558,7 +558,7 @@ public static float MinMagnitude(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static void MinMagnitude(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) =>
-            InvokeSpanSpanIntoSpan<MinMagnitudePropagateNaNOperator>(x, y, destination);
+            InvokeSpanSpanIntoSpan<MinMagnitudePropagateNaNOperator_Single>(x, y, destination);
 
         /// <summary>Computes the element-wise product of single-precision floating-point numbers in the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -577,7 +577,7 @@ public static void MinMagnitude(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Sp
         /// </para>
         /// </remarks>
         public static void Multiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) =>
-            InvokeSpanSpanIntoSpan<MultiplyOperator>(x, y, destination);
+            InvokeSpanSpanIntoSpan<MultiplyOperator_Single>(x, y, destination);
 
         /// <summary>Computes the element-wise product of single-precision floating-point numbers in the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -595,7 +595,7 @@ public static void Multiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<f
         /// </para>
         /// </remarks>
         public static void Multiply(ReadOnlySpan<float> x, float y, Span<float> destination) =>
-            InvokeSpanScalarIntoSpan<MultiplyOperator>(x, y, destination);
+            InvokeSpanScalarIntoSpan<MultiplyOperator_Single>(x, y, destination);
 
         /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of single-precision floating-point numbers.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -616,7 +616,7 @@ public static void Multiply(ReadOnlySpan<float> x, float y, Span<float> destinat
         /// </para>
         /// </remarks>
         public static void MultiplyAdd(ReadOnlySpan<float> x, ReadOnlySpan<float> y, ReadOnlySpan<float> addend, Span<float> destination) =>
-            InvokeSpanSpanSpanIntoSpan<MultiplyAddOperator>(x, y, addend, destination);
+            InvokeSpanSpanSpanIntoSpan<MultiplyAddOperator_Single>(x, y, addend, destination);
 
         /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of single-precision floating-point numbers.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -637,7 +637,7 @@ public static void MultiplyAdd(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Rea
         /// </para>
         /// </remarks>
         public static void MultiplyAdd(ReadOnlySpan<float> x, ReadOnlySpan<float> y, float addend, Span<float> destination) =>
-            InvokeSpanSpanScalarIntoSpan<MultiplyAddOperator>(x, y, addend, destination);
+            InvokeSpanSpanScalarIntoSpan<MultiplyAddOperator_Single>(x, y, addend, destination);
 
         /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of single-precision floating-point numbers.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -657,7 +657,7 @@ public static void MultiplyAdd(ReadOnlySpan<float> x, ReadOnlySpan<float> y, flo
         /// </para>
         /// </remarks>
         public static void MultiplyAdd(ReadOnlySpan<float> x, float y, ReadOnlySpan<float> addend, Span<float> destination) =>
-            InvokeSpanScalarSpanIntoSpan<MultiplyAddOperator>(x, y, addend, destination);
+            InvokeSpanScalarSpanIntoSpan<MultiplyAddOperator_Single>(x, y, addend, destination);
 
         /// <summary>Computes the element-wise negation of each single-precision floating-point number in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -673,7 +673,7 @@ public static void MultiplyAdd(ReadOnlySpan<float> x, float y, ReadOnlySpan<floa
         /// </para>
         /// </remarks>
         public static void Negate(ReadOnlySpan<float> x, Span<float> destination) =>
-            InvokeSpanIntoSpan<NegateOperator>(x, destination);
+            InvokeSpanIntoSpan<NegateOperator_Single>(x, destination);
 
         /// <summary>Computes the Euclidean norm of the specified tensor of single-precision floating-point numbers.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -715,7 +715,7 @@ public static float Product(ReadOnlySpan<float> x)
                 ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
             }
 
-            return Aggregate<IdentityOperator, MultiplyOperator>(x);
+            return Aggregate<IdentityOperator_Single, MultiplyOperator_Single>(x);
         }
 
         /// <summary>Computes the product of the element-wise differences of the single-precision floating-point numbers in the specified non-empty tensors.</summary>
@@ -746,7 +746,7 @@ public static float ProductOfDifferences(ReadOnlySpan<float> x, ReadOnlySpan<flo
                 ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
             }
 
-            return Aggregate<SubtractOperator, MultiplyOperator>(x, y);
+            return Aggregate<SubtractOperator_Single, MultiplyOperator_Single>(x, y);
         }
 
         /// <summary>Computes the product of the element-wise sums of the single-precision floating-point numbers in the specified non-empty tensors.</summary>
@@ -777,7 +777,7 @@ public static float ProductOfSums(ReadOnlySpan<float> x, ReadOnlySpan<float> y)
                 ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
             }
 
-            return Aggregate<AddOperator, MultiplyOperator>(x, y);
+            return Aggregate<AddOperator_Single, MultiplyOperator_Single>(x, y);
         }
 
         /// <summary>Computes the element-wise sigmoid function on the specified non-empty tensor of single-precision floating-point numbers.</summary>
@@ -802,7 +802,7 @@ public static void Sigmoid(ReadOnlySpan<float> x, Span<float> destination)
                 ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
             }
 
-            InvokeSpanIntoSpan<SigmoidOperator>(x, destination);
+            InvokeSpanIntoSpan<SigmoidOperator_Single>(x, destination);
         }
 
         /// <summary>Computes the element-wise hyperbolic sine of each single-precision floating-point radian angle in the specified tensor.</summary>
@@ -827,7 +827,7 @@ public static void Sigmoid(ReadOnlySpan<float> x, Span<float> destination)
         /// </para>
         /// </remarks>
         public static void Sinh(ReadOnlySpan<float> x, Span<float> destination) =>
-            InvokeSpanIntoSpan<SinhOperator>(x, destination);
+            InvokeSpanIntoSpan<SinhOperator_Single>(x, destination);
 
         /// <summary>Computes the softmax function over the specified non-empty tensor of single-precision floating-point numbers.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -859,9 +859,9 @@ public static void SoftMax(ReadOnlySpan<float> x, Span<float> destination)
 
             ValidateInputOutputSpanNonOverlapping(x, destination);
 
-            float expSum = Aggregate<ExpOperator, AddOperator>(x);
+            float expSum = Aggregate<ExpOperator_Single, AddOperator_Single>(x);
 
-            InvokeSpanScalarIntoSpan<ExpOperator, DivideOperator>(x, expSum, destination);
+            InvokeSpanScalarIntoSpan<ExpOperator_Single, DivideOperator_Single>(x, expSum, destination);
         }
 
         /// <summary>Computes the element-wise difference between single-precision floating-point numbers in the specified tensors.</summary>
@@ -881,7 +881,7 @@ public static void SoftMax(ReadOnlySpan<float> x, Span<float> destination)
         /// </para>
         /// </remarks>
         public static void Subtract(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) =>
-            InvokeSpanSpanIntoSpan<SubtractOperator>(x, y, destination);
+            InvokeSpanSpanIntoSpan<SubtractOperator_Single>(x, y, destination);
 
         /// <summary>Computes the element-wise difference between single-precision floating-point numbers in the specified tensors.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
@@ -898,7 +898,7 @@ public static void Subtract(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<f
         /// </para>
         /// </remarks>
         public static void Subtract(ReadOnlySpan<float> x, float y, Span<float> destination) =>
-            InvokeSpanScalarIntoSpan<SubtractOperator>(x, y, destination);
+            InvokeSpanScalarIntoSpan<SubtractOperator_Single>(x, y, destination);
 
         /// <summary>Computes the sum of all elements in the specified tensor of single-precision floating-point numbers.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -913,7 +913,7 @@ public static void Subtract(ReadOnlySpan<float> x, float y, Span<float> destinat
         /// </para>
         /// </remarks>
         public static float Sum(ReadOnlySpan<float> x) =>
-            Aggregate<IdentityOperator, AddOperator>(x);
+            Aggregate<IdentityOperator_Single, AddOperator_Single>(x);
 
         /// <summary>Computes the sum of the absolute values of every element in the specified tensor of single-precision floating-point numbers.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -934,7 +934,7 @@ public static float Sum(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static float SumOfMagnitudes(ReadOnlySpan<float> x) =>
-            Aggregate<AbsoluteOperator, AddOperator>(x);
+            Aggregate<AbsoluteOperator_Single, AddOperator_Single>(x);
 
         /// <summary>Computes the sum of the square of every element in the specified tensor of single-precision floating-point numbers.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -955,7 +955,7 @@ public static float SumOfMagnitudes(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static float SumOfSquares(ReadOnlySpan<float> x) =>
-            Aggregate<SquaredOperator, AddOperator>(x);
+            Aggregate<SquaredOperator_Single, AddOperator_Single>(x);
 
         /// <summary>Computes the element-wise hyperbolic tangent of each single-precision floating-point radian angle in the specified tensor.</summary>
         /// <param name="x">The tensor, represented as a span.</param>
@@ -980,78 +980,6 @@ public static float SumOfSquares(ReadOnlySpan<float> x) =>
         /// </para>
         /// </remarks>
         public static void Tanh(ReadOnlySpan<float> x, Span<float> destination) =>
-            InvokeSpanIntoSpan<TanhOperator>(x, destination);
-
-        /// <summary>Throws an exception if the <paramref name="input"/> and <paramref name="output"/> spans overlap and don't begin at the same memory location.</summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void ValidateInputOutputSpanNonOverlapping(ReadOnlySpan<float> input, Span<float> output)
-        {
-            if (!Unsafe.AreSame(ref MemoryMarshal.GetReference(input), ref MemoryMarshal.GetReference(output)) &&
-                input.Overlaps(output))
-            {
-                ThrowHelper.ThrowArgument_InputAndDestinationSpanMustNotOverlap();
-            }
-        }
-
-        /// <summary>Mask used to handle alignment elements before vectorized handling of the input.</summary>
-        /// <remarks>
-        /// Logically 16 rows of 16 uints. The Nth row should be used to handle N alignment elements at the
-        /// beginning of the input, where elements in the vector after that will be zero'd.
-        ///
-        /// There actually exists 17 rows in the table with the last row being a repeat of the first. This is
-        /// done because it allows the main algorithms to use a simplified algorithm when computing the amount
-        /// of misalignment where we always skip the first 16 elements, even if already aligned, so we don't
-        /// double process them. This allows us to avoid an additional branch.
-        /// </remarks>
-        private static ReadOnlySpan<uint> AlignmentUInt32Mask_16x16 =>
-        [
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000,
-            0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-        ];
-
-        /// <summary>Mask used to handle remaining elements after vectorized handling of the input.</summary>
-        /// <remarks>
-        /// Logically 16 rows of 16 uints. The Nth row should be used to handle N remaining elements at the
-        /// end of the input, where elements in the vector prior to that will be zero'd.
-        ///
-        /// Much as with the AlignmentMask table, we actually have 17 rows where the last row is a repeat of
-        /// the first. Doing this allows us to avoid an additional branch and instead to always process the
-        /// last 16 elements via a conditional select instead.
-        /// </remarks>
-        private static ReadOnlySpan<uint> RemainderUInt32Mask_16x16 =>
-        [
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-            0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
-        ];
+            InvokeSpanIntoSpan<TanhOperator_Single>(x, destination);
     }
 }
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
new file mode 100644
index 00000000000000..3747906c5317e6
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Single.netcore.cs
@@ -0,0 +1,98 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// This file exists to enable TensorPrimitives.float.cs to be compiled for both
+// netstandard2.0 and net8.0+ targets. It uses the XX_Single names and the operation
+// methods tied to float, whereas the net8.0+ worker implementations use generic math.
+// This file provides float-bound types and type defs that route one to the other.
+
+global using AbsoluteOperator_Single = System.Numerics.Tensors.TensorPrimitives.AbsoluteOperator<float>;
+global using AddOperator_Single = System.Numerics.Tensors.TensorPrimitives.AddOperator<float>;
+global using AddMultiplyOperator_Single = System.Numerics.Tensors.TensorPrimitives.AddMultiplyOperator<float>;
+global using CoshOperator_Single = System.Numerics.Tensors.TensorPrimitives.CoshOperator<float>;
+global using SubtractSquaredOperator_Single = System.Numerics.Tensors.TensorPrimitives.SubtractSquaredOperator<float>;
+global using DivideOperator_Single = System.Numerics.Tensors.TensorPrimitives.DivideOperator<float>;
+global using MultiplyOperator_Single = System.Numerics.Tensors.TensorPrimitives.MultiplyOperator<float>;
+global using ExpOperator_Single = System.Numerics.Tensors.TensorPrimitives.ExpOperator<float>;
+global using LogOperator_Single = System.Numerics.Tensors.TensorPrimitives.LogOperator<float>;
+global using Log2Operator_Single = System.Numerics.Tensors.TensorPrimitives.Log2Operator<float>;
+global using MaxOperator_Single = System.Numerics.Tensors.TensorPrimitives.MaxOperator<float>;
+global using MaxPropagateNaNOperator_Single = System.Numerics.Tensors.TensorPrimitives.MaxPropagateNaNOperator<float>;
+global using MaxMagnitudeOperator_Single = System.Numerics.Tensors.TensorPrimitives.MaxMagnitudeOperator<float>;
+global using MaxMagnitudePropagateNaNOperator_Single = System.Numerics.Tensors.TensorPrimitives.MaxMagnitudePropagateNaNOperator<float>;
+global using MinOperator_Single = System.Numerics.Tensors.TensorPrimitives.MinOperator<float>;
+global using MinPropagateNaNOperator_Single = System.Numerics.Tensors.TensorPrimitives.MinPropagateNaNOperator<float>;
+global using MinMagnitudeOperator_Single = System.Numerics.Tensors.TensorPrimitives.MinMagnitudeOperator<float>;
+global using MinMagnitudePropagateNaNOperator_Single = System.Numerics.Tensors.TensorPrimitives.MinMagnitudePropagateNaNOperator<float>;
+global using MultiplyAddOperator_Single = System.Numerics.Tensors.TensorPrimitives.MultiplyAddOperator<float>;
+global using NegateOperator_Single = System.Numerics.Tensors.TensorPrimitives.NegateOperator<float>;
+global using IdentityOperator_Single = System.Numerics.Tensors.TensorPrimitives.IdentityOperator<float>;
+global using SubtractOperator_Single = System.Numerics.Tensors.TensorPrimitives.SubtractOperator<float>;
+global using SigmoidOperator_Single = System.Numerics.Tensors.TensorPrimitives.SigmoidOperator<float>;
+global using SinhOperator_Single = System.Numerics.Tensors.TensorPrimitives.SinhOperator<float>;
+global using SquaredOperator_Single = System.Numerics.Tensors.TensorPrimitives.SquaredOperator<float>;
+global using TanhOperator_Single = System.Numerics.Tensors.TensorPrimitives.TanhOperator<float>;
+
+// TODO: These should be made generic. Their implementations are still currently bound to float.
+global using IndexOfMaxOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMaxOperator;
+global using IndexOfMaxMagnitudeOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMaxMagnitudeOperator;
+global using IndexOfMinOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMinOperator;
+global using IndexOfMinMagnitudeOperator_Single = System.Numerics.Tensors.TensorPrimitives.IndexOfMinMagnitudeOperator;
+
+namespace System.Numerics.Tensors
+{
+    public static unsafe partial class TensorPrimitives
+    {
+        private static void InvokeSpanIntoSpan<TSingleUnaryOperator>(
+            ReadOnlySpan<float> x, Span<float> destination)
+            where TSingleUnaryOperator : struct, IUnaryOperator<float> =>
+            InvokeSpanIntoSpan<float, TSingleUnaryOperator>(x, destination);
+
+        private static void InvokeSpanSpanIntoSpan<TSingleBinaryOperator>(
+            ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination)
+            where TSingleBinaryOperator : struct, IBinaryOperator<float> =>
+            InvokeSpanSpanIntoSpan<float, TSingleBinaryOperator>(x, y, destination);
+
+        private static void InvokeSpanScalarIntoSpan<TSingleBinaryOperator>(
+            ReadOnlySpan<float> x, float y, Span<float> destination)
+            where TSingleBinaryOperator : struct, IBinaryOperator<float> =>
+            InvokeSpanScalarIntoSpan<float, IdentityOperator<float>, TSingleBinaryOperator>(x, y, destination);
+
+        private static unsafe void InvokeSpanScalarIntoSpan<TSingleTransformOperator, TSingleBinaryOperator>(
+            ReadOnlySpan<float> x, float y, Span<float> destination)
+            where TSingleTransformOperator : struct, IUnaryOperator<float>
+            where TSingleBinaryOperator : struct, IBinaryOperator<float> =>
+            InvokeSpanScalarIntoSpan<float, TSingleTransformOperator, TSingleBinaryOperator>(x, y, destination);
+
+        private static unsafe void InvokeSpanSpanSpanIntoSpan<TSingleTernaryOperator>(
+            ReadOnlySpan<float> x, ReadOnlySpan<float> y, ReadOnlySpan<float> z, Span<float> destination)
+            where TSingleTernaryOperator : struct, ITernaryOperator<float> =>
+            InvokeSpanSpanSpanIntoSpan<float, TSingleTernaryOperator>(x, y, z, destination);
+
+        private static void InvokeSpanSpanScalarIntoSpan<TSingleTernaryOperator>(
+            ReadOnlySpan<float> x, ReadOnlySpan<float> y, float z, Span<float> destination)
+            where TSingleTernaryOperator : struct, ITernaryOperator<float> =>
+            InvokeSpanSpanScalarIntoSpan<float, TSingleTernaryOperator>(x, y, z, destination);
+
+        private static void InvokeSpanScalarSpanIntoSpan<TSingleTernaryOperator>(
+            ReadOnlySpan<float> x, float y, ReadOnlySpan<float> z, Span<float> destination)
+            where TSingleTernaryOperator : struct, ITernaryOperator<float> =>
+            InvokeSpanScalarSpanIntoSpan<float, TSingleTernaryOperator>(x, y, z, destination);
+
+        private static unsafe float Aggregate<TSingleTransformOperator, TSingleAggregationOperator>(
+            ReadOnlySpan<float> x)
+            where TSingleTransformOperator : struct, IUnaryOperator<float>
+            where TSingleAggregationOperator : struct, IAggregationOperator<float> =>
+            Aggregate<float, TSingleTransformOperator, TSingleAggregationOperator>(x);
+
+        private static float Aggregate<TSingleBinaryOperator, TSingleAggregationOperator>(
+            ReadOnlySpan<float> x, ReadOnlySpan<float> y)
+            where TSingleBinaryOperator : struct, IBinaryOperator<float>
+            where TSingleAggregationOperator : struct, IAggregationOperator<float> =>
+            Aggregate<float, TSingleBinaryOperator, TSingleAggregationOperator>(x, y);
+
+        private static float MinMaxCore<TSingleMinMaxOperator>(ReadOnlySpan<float> x)
+            where TSingleMinMaxOperator : struct, IAggregationOperator<float> =>
+            MinMaxCore<float, TSingleMinMaxOperator>(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
new file mode 100644
index 00000000000000..f9a44e8680123d
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.T.cs
@@ -0,0 +1,1036 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// TODO:
+// - Provide generic overloads for the IndexOfMin/Max{Magnitude} methods
+namespace System.Numerics.Tensors
+{
+    /// <summary>Performs primitive tensor operations over spans of memory.</summary>
+    public static partial class TensorPrimitives
+    {
+        /// <summary>Computes the element-wise absolute value of each number in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="OverflowException"><typeparamref name="T"/> is a signed integer type and <paramref name="x"/> contained a value equal to <typeparamref name="T"/>'s minimum value.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = MathF.Abs(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The absolute value of a <typeparamref name="T"/> is its numeric value without its sign. For example, the absolute value of both 1.2e-03 and -1.2e03 is 1.2e03.
+        /// </para>
+        /// <para>
+        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/> or <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
+        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is the original NaN value with the sign bit removed.
+        /// </para>
+        /// </remarks>
+        public static void Abs<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : INumberBase<T> =>
+            InvokeSpanIntoSpan<T, AbsoluteOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise addition of numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] + <paramref name="y" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Add<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T> =>
+            InvokeSpanSpanIntoSpan<T, AddOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise addition of numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a scalar.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] + <paramref name="y" /></c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Add<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T> =>
+            InvokeSpanScalarIntoSpan<T, AddOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="multiplier">The third tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" /> and the length of <paramref name="multiplier" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="multiplier"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = (<paramref name="x" />[i] + <paramref name="y" />[i]) * <paramref name="multiplier" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void AddMultiply<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> multiplier, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanSpanSpanIntoSpan<T, AddMultiplyOperator<T>>(x, y, multiplier, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="multiplier">The third tensor, represented as a scalar.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = (<paramref name="x" />[i] + <paramref name="y" />[i]) * <paramref name="multiplier" /></c>.
+        /// </para>
+        /// <para>
+        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void AddMultiply<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T multiplier, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanSpanScalarIntoSpan<T, AddMultiplyOperator<T>>(x, y, multiplier, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c> for the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a scalar.</param>
+        /// <param name="multiplier">The third tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="multiplier" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="multiplier"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = (<paramref name="x" />[i] + <paramref name="y" />) * <paramref name="multiplier" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void AddMultiply<T>(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> multiplier, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanScalarSpanIntoSpan<T, AddMultiplyOperator<T>>(x, y, multiplier, destination);
+
+        /// <summary>Computes the element-wise hyperbolic cosine of each radian angle in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <see cref="MathF" />.Cosh(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/> or <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
+        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is also NaN.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <see cref="MathF.PI"/>/180 to convert degrees to radians.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void Cosh<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IHyperbolicFunctions<T> =>
+            InvokeSpanIntoSpan<T, CoshOperator<T>>(x, destination);
+
+        /// <summary>Computes the cosine similarity between the two specified non-empty, equal-length tensors of numbers.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <returns>The cosine similarity of the two tensors.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x" /> and <paramref name="y" /> must not be empty.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c>TensorPrimitives.Dot(x, y) / (MathF.Sqrt(TensorPrimitives.SumOfSquares(x)) * MathF.Sqrt(TensorPrimitives.SumOfSquares(y)).</c>
+        /// </para>
+        /// <para>
+        /// If any element in either input tensor is equal to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>, <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, or <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// NaN is returned.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T CosineSimilarity<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
+            where T : IRootFunctions<T> =>
+            CosineSimilarityCore(x, y);
+
+        /// <summary>Computes the distance between two points, specified as non-empty, equal-length tensors of numbers, in Euclidean space.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <returns>The Euclidean distance.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x" /> and <paramref name="y" /> must not be empty.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes the equivalent of:
+        /// <c>
+        ///     Span&lt;T&gt; difference = ...;
+        ///     TensorPrimitives.Subtract(x, y, difference);
+        ///     T result = MathF.Sqrt(TensorPrimitives.SumOfSquares(difference));
+        /// </c>
+        /// but without requiring additional temporary storage for the intermediate differences.
+        /// </para>
+        /// <para>
+        /// If any element in either input tensor is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, NaN is returned.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T Distance<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
+            where T : IRootFunctions<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            return T.Sqrt(Aggregate<T, SubtractSquaredOperator<T>, AddOperator<T>>(x, y));
+        }
+
+        /// <summary>Computes the element-wise division of numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="DivideByZeroException"><typeparamref name="T"/> is an integer type and an element in <paramref name="y"/> is equal to zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] / <paramref name="y" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Divide<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IDivisionOperators<T, T, T> =>
+            InvokeSpanSpanIntoSpan<T, DivideOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise division of numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a scalar.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="DivideByZeroException"><typeparamref name="T"/> is an integer type and <paramref name="y"/> is equal to zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] / <paramref name="y" /></c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Divide<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : IDivisionOperators<T, T, T> =>
+            InvokeSpanScalarIntoSpan<T, DivideOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the dot product of two tensors containing numbers.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <returns>The dot product.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes the equivalent of:
+        /// <c>
+        ///     Span&lt;T&gt; products = ...;
+        ///     TensorPrimitives.Multiply(x, y, products);
+        ///     T result = TensorPrimitives.Sum(products);
+        /// </c>
+        /// but without requiring additional temporary storage for the intermediate products. It corresponds to the <c>dot</c> method defined by <c>BLAS1</c>.
+        /// </para>
+        /// <para>
+        /// If any of the input elements is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting value is also NaN.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T Dot<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T> =>
+            Aggregate<T, MultiplyOperator<T>, AddOperator<T>>(x, y);
+
+        /// <summary>Computes the element-wise result of raising <c>e</c> to the number powers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <see cref="MathF" />.Exp(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value equals <see cref="IFloatingPointIeee754{TSelf}.NaN"/> or <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, the result stored into the corresponding destination location is set to NaN.
+        /// If a value equals <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>, the result stored into the corresponding destination location is set to 0.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void Exp<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IExponentialFunctions<T> =>
+            InvokeSpanIntoSpan<T, ExpOperator<T>>(x, destination);
+
+        // TODO: Make IndexOfXx methods generic
+        //
+        ///// <summary>Searches for the index of the largest number in the specified tensor.</summary>
+        ///// <param name="x">The tensor, represented as a span.</param>
+        ///// <returns>The index of the maximum element in <paramref name="x"/>, or -1 if <paramref name="x"/> is empty.</returns>
+        ///// <remarks>
+        ///// <para>
+        ///// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        ///// is present, the index of the first is returned. Positive 0 is considered greater than negative 0.
+        ///// </para>
+        ///// <para>
+        ///// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        ///// operating systems or architectures.
+        ///// </para>
+        ///// </remarks>
+        //public static int IndexOfMax<T>(ReadOnlySpan<T> x)
+        //    where T : INumber<T> =>
+        //    IndexOfMinMaxCore<T, IndexOfMaxOperator<T>>(x);
+        //
+        ///// <summary>Searches for the index of the number with the largest magnitude in the specified tensor.</summary>
+        ///// <param name="x">The tensor, represented as a span.</param>
+        ///// <returns>The index of the element in <paramref name="x"/> with the largest magnitude (absolute value), or -1 if <paramref name="x"/> is empty.</returns>
+        ///// <remarks>
+        ///// <para>
+        ///// The determination of the maximum magnitude matches the IEEE 754:2019 `maximumMagnitude` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        ///// is present, the index of the first is returned. If two values have the same magnitude and one is positive and the other is negative,
+        ///// the positive value is considered to have the larger magnitude.
+        ///// </para>
+        ///// <para>
+        ///// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        ///// operating systems or architectures.
+        ///// </para>
+        ///// </remarks>
+        //public static int IndexOfMaxMagnitude<T>(ReadOnlySpan<T> x)
+        //    where T : INumberBase<T> =>
+        //    IndexOfMinMaxCore<T, IndexOfMaxMagnitudeOperator<T>>(x);
+        //
+        ///// <summary>Searches for the index of the smallest number in the specified tensor.</summary>
+        ///// <param name="x">The tensor, represented as a span.</param>
+        ///// <returns>The index of the minimum element in <paramref name="x"/>, or -1 if <paramref name="x"/> is empty.</returns>
+        ///// <remarks>
+        ///// <para>
+        ///// The determination of the minimum element matches the IEEE 754:2019 `minimum` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        ///// is present, the index of the first is returned. Negative 0 is considered smaller than positive 0.
+        ///// </para>
+        ///// <para>
+        ///// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        ///// operating systems or architectures.
+        ///// </para>
+        ///// </remarks>
+        //public static int IndexOfMin<T>(ReadOnlySpan<T> x)
+        //    where T : INumber<T> =>
+        //    IndexOfMinMaxCore<T, IndexOfMinOperator<T>>(x);
+        //
+        ///// <summary>Searches for the index of the number with the smallest magnitude in the specified tensor.</summary>
+        ///// <param name="x">The tensor, represented as a span.</param>
+        ///// <returns>The index of the element in <paramref name="x"/> with the smallest magnitude (absolute value), or -1 if <paramref name="x"/> is empty.</returns>
+        ///// <remarks>
+        ///// <para>
+        ///// The determination of the minimum magnitude matches the IEEE 754:2019 `minimumMagnitude` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        ///// is present, the index of the first is returned. If two values have the same magnitude and one is positive and the other is negative,
+        ///// the negative value is considered to have the smaller magnitude.
+        ///// </para>
+        ///// <para>
+        ///// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        ///// operating systems or architectures.
+        ///// </para>
+        ///// </remarks>
+        //public static int IndexOfMinMagnitude<T>(ReadOnlySpan<T> x)
+        //    where T : INumberBase<T> =>
+        //    IndexOfMinMaxCore<T, IndexOfMinMagnitudeOperator<T>>(x);
+
+        /// <summary>Computes the element-wise natural (base <c>e</c>) logarithm of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <see cref="MathF" />.Log(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value equals 0, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>.
+        /// If a value is negative or equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is set to NaN.
+        /// If a value is positive infinity, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
+        /// Otherwise, if a value is positive, its natural logarithm is stored into the corresponding destination location.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void Log<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ILogarithmicFunctions<T> =>
+            InvokeSpanIntoSpan<T, LogOperator<T>>(x, destination);
+
+        /// <summary>Computes the element-wise base 2 logarithm of numbers in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <see cref="MathF" />.Log2(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value equals 0, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>.
+        /// If a value is negative or equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result stored into the corresponding destination location is set to NaN.
+        /// If a value is positive infinity, the result stored into the corresponding destination location is set to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>.
+        /// Otherwise, if a value is positive, its natural logarithm is stored into the corresponding destination location.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void Log2<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : ILogarithmicFunctions<T> =>
+            InvokeSpanIntoSpan<T, Log2Operator<T>>(x, destination);
+
+        /// <summary>Searches for the largest number in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The maximum element in <paramref name="x"/>.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        /// is present, the first is returned. Positive 0 is considered greater than negative 0.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T Max<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            MinMaxCore<T, MaxOperator<T>>(x);
+
+        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = MathF.Max(<paramref name="x" />[i], <paramref name="y" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// that value is stored as the result. Positive 0 is considered greater than negative 0.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void Max<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : INumber<T> =>
+            InvokeSpanSpanIntoSpan<T, MaxPropagateNaNOperator<T>>(x, y, destination);
+
+        /// <summary>Searches for the number with the largest magnitude in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The element in <paramref name="x"/> with the largest magnitude (absolute value).</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// The determination of the maximum magnitude matches the IEEE 754:2019 `maximumMagnitude` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        /// is present, the first is returned. If two values have the same magnitude and one is positive and the other is negative,
+        /// the positive value is considered to have the larger magnitude.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T MaxMagnitude<T>(ReadOnlySpan<T> x)
+            where T : INumberBase<T> =>
+            MinMaxCore<T, MaxMagnitudeOperator<T>>(x);
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>This method effectively computes <c><paramref name="destination" />[i] = MathF.MaxMagnitude(<paramref name="x" />[i], <paramref name="y" />[i])</c>.</remarks>
+        /// <remarks>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void MaxMagnitude<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : INumberBase<T> =>
+            InvokeSpanSpanIntoSpan<T, MaxMagnitudePropagateNaNOperator<T>>(x, y, destination);
+
+        /// <summary>Searches for the smallest number in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The minimum element in <paramref name="x"/>.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// The determination of the minimum element matches the IEEE 754:2019 `minimum` function. If any value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        /// is present, the first is returned. Negative 0 is considered smaller than positive 0.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T Min<T>(ReadOnlySpan<T> x)
+            where T : INumber<T> =>
+            MinMaxCore<T, MinOperator<T>>(x);
+
+        /// <summary>Computes the element-wise minimum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = MathF.Max(<paramref name="x" />[i], <paramref name="y" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The determination of the maximum element matches the IEEE 754:2019 `maximum` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// that value is stored as the result. Positive 0 is considered greater than negative 0.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void Min<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : INumber<T> =>
+            InvokeSpanSpanIntoSpan<T, MinPropagateNaNOperator<T>>(x, y, destination);
+
+        /// <summary>Searches for the number with the smallest magnitude in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The element in <paramref name="x"/> with the smallest magnitude (absolute value).</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// The determination of the minimum magnitude matches the IEEE 754:2019 `minimumMagnitude` function. If any value equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>
+        /// is present, the first is returned. If two values have the same magnitude and one is positive and the other is negative,
+        /// the negative value is considered to have the smaller magnitude.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T MinMagnitude<T>(ReadOnlySpan<T> x)
+            where T : INumberBase<T> =>
+            MinMaxCore<T, MinMagnitudeOperator<T>>(x);
+
+        /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>This method effectively computes <c><paramref name="destination" />[i] = MathF.MinMagnitude(<paramref name="x" />[i], <paramref name="y" />[i])</c>.</remarks>
+        /// <remarks>
+        /// <para>
+        /// The determination of the maximum magnitude matches the IEEE 754:2019 `minimumMagnitude` function. If either value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// that value is stored as the result. If the two values have the same magnitude and one is positive and the other is negative,
+        /// the negative value is considered to have the smaller magnitude.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void MinMagnitude<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : INumberBase<T> =>
+            InvokeSpanSpanIntoSpan<T, MinMagnitudePropagateNaNOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise product of numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] * <paramref name="y" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Multiply<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T> =>
+            InvokeSpanSpanIntoSpan<T, MultiplyOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise product of numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a scalar.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] * <paramref name="y" /></c>.
+        /// It corresponds to the <c>scal</c> method defined by <c>BLAS1</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Multiply<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T> =>
+            InvokeSpanScalarIntoSpan<T, MultiplyOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="addend">The third tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" /> and length of <paramref name="addend" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="addend"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = (<paramref name="x" />[i] * <paramref name="y" />[i]) + <paramref name="addend" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void MultiplyAdd<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> addend, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanSpanSpanIntoSpan<T, MultiplyAddOperator<T>>(x, y, addend, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="addend">The third tensor, represented as a scalar.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = (<paramref name="x" />[i] * <paramref name="y" />[i]) + <paramref name="addend" /></c>.
+        /// It corresponds to the <c>axpy</c> method defined by <c>BLAS1</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void MultiplyAdd<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T addend, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanSpanScalarIntoSpan<T, MultiplyAddOperator<T>>(x, y, addend, destination);
+
+        /// <summary>Computes the element-wise result of <c>(<paramref name="x" /> * <paramref name="y" />) * <paramref name="addend" /></c> for the specified tensors of numbers.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a scalar.</param>
+        /// <param name="addend">The third tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="addend" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="addend"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = (<paramref name="x" />[i] * <paramref name="y" />) + <paramref name="addend" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void MultiplyAdd<T>(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> addend, Span<T> destination)
+            where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T> =>
+            InvokeSpanScalarSpanIntoSpan<T, MultiplyAddOperator<T>>(x, y, addend, destination);
+
+        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = -<paramref name="x" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If any of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Negate<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IUnaryNegationOperators<T, T> =>
+            InvokeSpanIntoSpan<T, NegateOperator<T>>(x, destination);
+
+        /// <summary>Computes the Euclidean norm of the specified tensor of numbers.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <returns>The norm.</returns>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c>MathF.Sqrt(TensorPrimitives.SumOfSquares(x))</c>.
+        /// This is often referred to as the Euclidean norm or L2 norm.
+        /// It corresponds to the <c>nrm2</c> method defined by <c>BLAS1</c>.
+        /// </para>
+        /// <para>
+        /// If any of the input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result value is also NaN.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T Norm<T>(ReadOnlySpan<T> x)
+            where T : IRootFunctions<T> =>
+            T.Sqrt(SumOfSquares(x));
+
+        /// <summary>Computes the product of all elements in the specified non-empty tensor of numbers.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The result of multiplying all elements in <paramref name="x"/>.</returns>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be greater than zero.</exception>
+        /// <remarks>
+        /// <para>
+        /// If any of the input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result value is also NaN.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T Product<T>(ReadOnlySpan<T> x)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            return Aggregate<T, IdentityOperator<T>, MultiplyOperator<T>>(x);
+        }
+
+        /// <summary>Computes the product of the element-wise differences of the numbers in the specified non-empty tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <returns>The result of multiplying the element-wise subtraction of the elements in the second tensor from the first tensor.</returns>
+        /// <exception cref="ArgumentException">Length of both input spans must be greater than zero.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="y"/> must have the same length.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes:
+        /// <c>
+        ///     Span&lt;T&gt; differences = ...;
+        ///     TensorPrimitives.Subtract(x, y, differences);
+        ///     T result = TensorPrimitives.Product(differences);
+        /// </c>
+        /// but without requiring additional temporary storage for the intermediate differences.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T ProductOfDifferences<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
+            where T : ISubtractionOperators<T, T, T>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            return Aggregate<T, SubtractOperator<T>, MultiplyOperator<T>>(x, y);
+        }
+
+        /// <summary>Computes the product of the element-wise sums of the numbers in the specified non-empty tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <returns>The result of multiplying the element-wise additions of the elements in each tensor.</returns>
+        /// <exception cref="ArgumentException">Length of both input spans must be greater than zero.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="y"/> must have the same length.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes:
+        /// <c>
+        ///     Span&lt;T&gt; sums = ...;
+        ///     TensorPrimitives.Add(x, y, sums);
+        ///     T result = TensorPrimitives.Product(sums);
+        /// </c>
+        /// but without requiring additional temporary storage for the intermediate sums.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T ProductOfSums<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            return Aggregate<T, AddOperator<T>, MultiplyOperator<T>>(x, y);
+        }
+
+        /// <summary>Computes the element-wise sigmoid function on the specified non-empty tensor of numbers.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x" /> must not be empty.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = 1f / (1f + <see cref="MathF" />.Exp(-<paramref name="x" />[i]))</c>.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void Sigmoid<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IExponentialFunctions<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            InvokeSpanIntoSpan<T, SigmoidOperator<T>>(x, destination);
+        }
+
+        /// <summary>Computes the element-wise hyperbolic sine of each radian angle in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <see cref="MathF" />.Sinh(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>, <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, or <see cref="IFloatingPointIeee754{TSelf}.NaN"/>,
+        /// the corresponding destination location is set to that value.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <see cref="MathF.PI"/>/180 to convert degrees to radians.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void Sinh<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IHyperbolicFunctions<T> =>
+            InvokeSpanIntoSpan<T, SinhOperator<T>>(x, destination);
+
+        /// <summary>Computes the softmax function over the specified non-empty tensor of numbers.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x" /> must not be empty.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes a sum of <c>MathF.Exp(x[i])</c> for all elements in <paramref name="x"/>.
+        /// It then effectively computes <c><paramref name="destination" />[i] = MathF.Exp(<paramref name="x" />[i]) / sum</c>.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void SoftMax<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IExponentialFunctions<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            ValidateInputOutputSpanNonOverlapping(x, destination);
+
+            T expSum = Aggregate<T, ExpOperator<T>, AddOperator<T>>(x);
+
+            InvokeSpanScalarIntoSpan<T, ExpOperator<T>, DivideOperator<T>>(x, expSum, destination);
+        }
+
+        /// <summary>Computes the element-wise difference between numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a scalar.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of <paramref name="x" /> must be same as length of <paramref name="y" />.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <exception cref="ArgumentException"><paramref name="y"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] - <paramref name="y" />[i]</c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Subtract<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where T : ISubtractionOperators<T, T, T> =>
+            InvokeSpanSpanIntoSpan<T, SubtractOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the element-wise difference between numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a scalar.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <paramref name="x" />[i] - <paramref name="y" /></c>.
+        /// </para>
+        /// <para>
+        /// If either of the element-wise input values is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the resulting element-wise value is also NaN.
+        /// </para>
+        /// </remarks>
+        public static void Subtract<T>(ReadOnlySpan<T> x, T y, Span<T> destination)
+            where T : ISubtractionOperators<T, T, T> =>
+            InvokeSpanScalarIntoSpan<T, SubtractOperator<T>>(x, y, destination);
+
+        /// <summary>Computes the sum of all elements in the specified tensor of numbers.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The result of adding all elements in <paramref name="x"/>, or zero if <paramref name="x"/> is empty.</returns>
+        /// <remarks>
+        /// <para>
+        /// If any of the values in the input is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the result is also NaN.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T Sum<T>(ReadOnlySpan<T> x)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T> =>
+            Aggregate<T, IdentityOperator<T>, AddOperator<T>>(x);
+
+        /// <summary>Computes the sum of the absolute values of every element in the specified tensor of numbers.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The result of adding the absolute value of every element in <paramref name="x"/>, or zero if <paramref name="x"/> is empty.</returns>
+        /// <exception cref="OverflowException"><typeparamref name="T"/> is a signed integer type and <paramref name="x"/> contained a value equal to <typeparamref name="T"/>'s minimum value.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes:
+        /// <c>
+        ///     Span&lt;T&gt; absoluteValues = ...;
+        ///     TensorPrimitives.Abs(x, absoluteValues);
+        ///     T result = TensorPrimitives.Sum(absoluteValues);
+        /// </c>
+        /// but without requiring intermediate storage for the absolute values. It corresponds to the <c>asum</c> method defined by <c>BLAS1</c>.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T SumOfMagnitudes<T>(ReadOnlySpan<T> x)
+            where T : INumberBase<T> =>
+            Aggregate<T, AbsoluteOperator<T>, AddOperator<T>>(x);
+
+        /// <summary>Computes the sum of the square of every element in the specified tensor of numbers.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <returns>The result of adding the square of every element in <paramref name="x"/>, or zero if <paramref name="x"/> is empty.</returns>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes:
+        /// <c>
+        ///     Span&lt;T&gt; squaredValues = ...;
+        ///     TensorPrimitives.Multiply(x, x, squaredValues);
+        ///     T result = TensorPrimitives.Sum(squaredValues);
+        /// </c>
+        /// but without requiring intermediate storage for the squared values.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static T SumOfSquares<T>(ReadOnlySpan<T> x)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T> =>
+            Aggregate<T, SquaredOperator<T>, AddOperator<T>>(x);
+
+        /// <summary>Computes the element-wise hyperbolic tangent of each radian angle in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <exception cref="ArgumentException"><paramref name="x"/> and <paramref name="destination"/> reference overlapping memory locations and do not begin at the same location.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><paramref name="destination" />[i] = <see cref="MathF" />.Tanh(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NegativeInfinity"/>, the corresponding destination location is set to -1.
+        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.PositiveInfinity"/>, the corresponding destination location is set to 1.
+        /// If a value is equal to <see cref="IFloatingPointIeee754{TSelf}.NaN"/>, the corresponding destination location is set to NaN.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <see cref="MathF.PI"/>/180 to convert degrees to radians.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static void Tanh<T>(ReadOnlySpan<T> x, Span<T> destination)
+            where T : IHyperbolicFunctions<T> =>
+            InvokeSpanIntoSpan<T, TanhOperator<T>>(x, destination);
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.netcore.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.netcore.cs
similarity index 65%
rename from src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.netcore.cs
rename to src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.netcore.cs
index 9b275e165158af..e8fec7a4bde585 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.netcore.cs
@@ -8,6 +8,13 @@
 using System.Runtime.Intrinsics.Arm;
 using System.Runtime.Intrinsics.X86;
 
+#pragma warning disable CS8500 // This takes the address of, gets the size of, or declares a pointer to a managed type
+
+// TODO:
+// - Vectorize the trig-related functions for Ts other than floats
+// - Vectorize integer operations when sizeof(T) == 1 or 2 (currently only vectorized in most operations for sizeof(T) == 4 or 8).
+// - Implement generic version of IndexOfMinMaxCore and corresponding IndexOf methods.
+
 namespace System.Numerics.Tensors
 {
     public static unsafe partial class TensorPrimitives
@@ -615,7 +622,7 @@ static Vector512<float> HalfAsWidenedUInt32ToSingle_Vector512(Vector512<uint> va
 
         /// <summary>Computes the cosine similarity between the two specified non-empty, equal-length tensors of single-precision floating-point numbers.</summary>
         /// <remarks>Assumes arguments have already been validated to be non-empty and equal length.</remarks>
-        private static float CosineSimilarityCore(ReadOnlySpan<float> x, ReadOnlySpan<float> y)
+        private static T CosineSimilarityCore<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y) where T : IRootFunctions<T>
         {
             if (x.IsEmpty)
             {
@@ -631,38 +638,38 @@ private static float CosineSimilarityCore(ReadOnlySpan<float> x, ReadOnlySpan<fl
             // TensorPrimitives.Dot(x, y) / (Math.Sqrt(TensorPrimitives.SumOfSquares(x)) * Math.Sqrt(TensorPrimitives.SumOfSquares(y)))
             // but only looping over each span once.
 
-            if (Vector512.IsHardwareAccelerated && x.Length >= Vector512<float>.Count)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count)
             {
-                ref float xRef = ref MemoryMarshal.GetReference(x);
-                ref float yRef = ref MemoryMarshal.GetReference(y);
+                ref T xRef = ref MemoryMarshal.GetReference(x);
+                ref T yRef = ref MemoryMarshal.GetReference(y);
 
-                Vector512<float> dotProductVector = Vector512<float>.Zero;
-                Vector512<float> xSumOfSquaresVector = Vector512<float>.Zero;
-                Vector512<float> ySumOfSquaresVector = Vector512<float>.Zero;
+                Vector512<T> dotProductVector = Vector512<T>.Zero;
+                Vector512<T> xSumOfSquaresVector = Vector512<T>.Zero;
+                Vector512<T> ySumOfSquaresVector = Vector512<T>.Zero;
 
                 // Process vectors, summing their dot products and squares, as long as there's a vector's worth remaining.
-                int oneVectorFromEnd = x.Length - Vector512<float>.Count;
+                int oneVectorFromEnd = x.Length - Vector512<T>.Count;
                 int i = 0;
                 do
                 {
-                    Vector512<float> xVec = Vector512.LoadUnsafe(ref xRef, (uint)i);
-                    Vector512<float> yVec = Vector512.LoadUnsafe(ref yRef, (uint)i);
+                    Vector512<T> xVec = Vector512.LoadUnsafe(ref xRef, (uint)i);
+                    Vector512<T> yVec = Vector512.LoadUnsafe(ref yRef, (uint)i);
 
                     dotProductVector = FusedMultiplyAdd(xVec, yVec, dotProductVector);
                     xSumOfSquaresVector = FusedMultiplyAdd(xVec, xVec, xSumOfSquaresVector);
                     ySumOfSquaresVector = FusedMultiplyAdd(yVec, yVec, ySumOfSquaresVector);
 
-                    i += Vector512<float>.Count;
+                    i += Vector512<T>.Count;
                 }
                 while (i <= oneVectorFromEnd);
 
                 // Process the last vector in the span, masking off elements already processed.
                 if (i != x.Length)
                 {
-                    Vector512<float> xVec = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<float>.Count));
-                    Vector512<float> yVec = Vector512.LoadUnsafe(ref yRef, (uint)(x.Length - Vector512<float>.Count));
+                    Vector512<T> xVec = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count));
+                    Vector512<T> yVec = Vector512.LoadUnsafe(ref yRef, (uint)(x.Length - Vector512<T>.Count));
 
-                    Vector512<float> remainderMask = CreateRemainderMaskSingleVector512(x.Length - i);
+                    Vector512<T> remainderMask = CreateRemainderMaskVector512<T>(x.Length - i);
                     xVec &= remainderMask;
                     yVec &= remainderMask;
 
@@ -674,41 +681,41 @@ private static float CosineSimilarityCore(ReadOnlySpan<float> x, ReadOnlySpan<fl
                 // Sum(X * Y) / (|X| * |Y|)
                 return
                     Vector512.Sum(dotProductVector) /
-                    (MathF.Sqrt(Vector512.Sum(xSumOfSquaresVector)) * MathF.Sqrt(Vector512.Sum(ySumOfSquaresVector)));
+                    (T.Sqrt(Vector512.Sum(xSumOfSquaresVector)) * T.Sqrt(Vector512.Sum(ySumOfSquaresVector)));
             }
 
-            if (Vector256.IsHardwareAccelerated && x.Length >= Vector256<float>.Count)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count)
             {
-                ref float xRef = ref MemoryMarshal.GetReference(x);
-                ref float yRef = ref MemoryMarshal.GetReference(y);
+                ref T xRef = ref MemoryMarshal.GetReference(x);
+                ref T yRef = ref MemoryMarshal.GetReference(y);
 
-                Vector256<float> dotProductVector = Vector256<float>.Zero;
-                Vector256<float> xSumOfSquaresVector = Vector256<float>.Zero;
-                Vector256<float> ySumOfSquaresVector = Vector256<float>.Zero;
+                Vector256<T> dotProductVector = Vector256<T>.Zero;
+                Vector256<T> xSumOfSquaresVector = Vector256<T>.Zero;
+                Vector256<T> ySumOfSquaresVector = Vector256<T>.Zero;
 
                 // Process vectors, summing their dot products and squares, as long as there's a vector's worth remaining.
-                int oneVectorFromEnd = x.Length - Vector256<float>.Count;
+                int oneVectorFromEnd = x.Length - Vector256<T>.Count;
                 int i = 0;
                 do
                 {
-                    Vector256<float> xVec = Vector256.LoadUnsafe(ref xRef, (uint)i);
-                    Vector256<float> yVec = Vector256.LoadUnsafe(ref yRef, (uint)i);
+                    Vector256<T> xVec = Vector256.LoadUnsafe(ref xRef, (uint)i);
+                    Vector256<T> yVec = Vector256.LoadUnsafe(ref yRef, (uint)i);
 
                     dotProductVector = FusedMultiplyAdd(xVec, yVec, dotProductVector);
                     xSumOfSquaresVector = FusedMultiplyAdd(xVec, xVec, xSumOfSquaresVector);
                     ySumOfSquaresVector = FusedMultiplyAdd(yVec, yVec, ySumOfSquaresVector);
 
-                    i += Vector256<float>.Count;
+                    i += Vector256<T>.Count;
                 }
                 while (i <= oneVectorFromEnd);
 
                 // Process the last vector in the span, masking off elements already processed.
                 if (i != x.Length)
                 {
-                    Vector256<float> xVec = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<float>.Count));
-                    Vector256<float> yVec = Vector256.LoadUnsafe(ref yRef, (uint)(x.Length - Vector256<float>.Count));
+                    Vector256<T> xVec = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count));
+                    Vector256<T> yVec = Vector256.LoadUnsafe(ref yRef, (uint)(x.Length - Vector256<T>.Count));
 
-                    Vector256<float> remainderMask = CreateRemainderMaskSingleVector256(x.Length - i);
+                    Vector256<T> remainderMask = CreateRemainderMaskVector256<T>(x.Length - i);
                     xVec &= remainderMask;
                     yVec &= remainderMask;
 
@@ -720,41 +727,41 @@ private static float CosineSimilarityCore(ReadOnlySpan<float> x, ReadOnlySpan<fl
                 // Sum(X * Y) / (|X| * |Y|)
                 return
                     Vector256.Sum(dotProductVector) /
-                    (MathF.Sqrt(Vector256.Sum(xSumOfSquaresVector)) * MathF.Sqrt(Vector256.Sum(ySumOfSquaresVector)));
+                    (T.Sqrt(Vector256.Sum(xSumOfSquaresVector)) * T.Sqrt(Vector256.Sum(ySumOfSquaresVector)));
             }
 
-            if (Vector128.IsHardwareAccelerated && x.Length >= Vector128<float>.Count)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && x.Length >= Vector128<T>.Count)
             {
-                ref float xRef = ref MemoryMarshal.GetReference(x);
-                ref float yRef = ref MemoryMarshal.GetReference(y);
+                ref T xRef = ref MemoryMarshal.GetReference(x);
+                ref T yRef = ref MemoryMarshal.GetReference(y);
 
-                Vector128<float> dotProductVector = Vector128<float>.Zero;
-                Vector128<float> xSumOfSquaresVector = Vector128<float>.Zero;
-                Vector128<float> ySumOfSquaresVector = Vector128<float>.Zero;
+                Vector128<T> dotProductVector = Vector128<T>.Zero;
+                Vector128<T> xSumOfSquaresVector = Vector128<T>.Zero;
+                Vector128<T> ySumOfSquaresVector = Vector128<T>.Zero;
 
                 // Process vectors, summing their dot products and squares, as long as there's a vector's worth remaining.
-                int oneVectorFromEnd = x.Length - Vector128<float>.Count;
+                int oneVectorFromEnd = x.Length - Vector128<T>.Count;
                 int i = 0;
                 do
                 {
-                    Vector128<float> xVec = Vector128.LoadUnsafe(ref xRef, (uint)i);
-                    Vector128<float> yVec = Vector128.LoadUnsafe(ref yRef, (uint)i);
+                    Vector128<T> xVec = Vector128.LoadUnsafe(ref xRef, (uint)i);
+                    Vector128<T> yVec = Vector128.LoadUnsafe(ref yRef, (uint)i);
 
                     dotProductVector = FusedMultiplyAdd(xVec, yVec, dotProductVector);
                     xSumOfSquaresVector = FusedMultiplyAdd(xVec, xVec, xSumOfSquaresVector);
                     ySumOfSquaresVector = FusedMultiplyAdd(yVec, yVec, ySumOfSquaresVector);
 
-                    i += Vector128<float>.Count;
+                    i += Vector128<T>.Count;
                 }
                 while (i <= oneVectorFromEnd);
 
                 // Process the last vector in the span, masking off elements already processed.
                 if (i != x.Length)
                 {
-                    Vector128<float> xVec = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<float>.Count));
-                    Vector128<float> yVec = Vector128.LoadUnsafe(ref yRef, (uint)(x.Length - Vector128<float>.Count));
+                    Vector128<T> xVec = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<T>.Count));
+                    Vector128<T> yVec = Vector128.LoadUnsafe(ref yRef, (uint)(x.Length - Vector128<T>.Count));
 
-                    Vector128<float> remainderMask = CreateRemainderMaskSingleVector128(x.Length - i);
+                    Vector128<T> remainderMask = CreateRemainderMaskVector128<T>(x.Length - i);
                     xVec &= remainderMask;
                     yVec &= remainderMask;
 
@@ -766,50 +773,51 @@ private static float CosineSimilarityCore(ReadOnlySpan<float> x, ReadOnlySpan<fl
                 // Sum(X * Y) / (|X| * |Y|)
                 return
                     Vector128.Sum(dotProductVector) /
-                    (MathF.Sqrt(Vector128.Sum(xSumOfSquaresVector)) * MathF.Sqrt(Vector128.Sum(ySumOfSquaresVector)));
+                    (T.Sqrt(Vector128.Sum(xSumOfSquaresVector)) * T.Sqrt(Vector128.Sum(ySumOfSquaresVector)));
             }
 
             // Vectorization isn't supported or there are too few elements to vectorize.
             // Use a scalar implementation.
-            float dotProduct = 0f, xSumOfSquares = 0f, ySumOfSquares = 0f;
+            T dotProduct = T.Zero, xSumOfSquares = T.Zero, ySumOfSquares = T.Zero;
             for (int i = 0; i < x.Length; i++)
             {
-                dotProduct = MathF.FusedMultiplyAdd(x[i], y[i], dotProduct);
-                xSumOfSquares = MathF.FusedMultiplyAdd(x[i], x[i], xSumOfSquares);
-                ySumOfSquares = MathF.FusedMultiplyAdd(y[i], y[i], ySumOfSquares);
+                dotProduct = FusedMultiplyAdd(x[i], y[i], dotProduct);
+                xSumOfSquares = FusedMultiplyAdd(x[i], x[i], xSumOfSquares);
+                ySumOfSquares = FusedMultiplyAdd(y[i], y[i], ySumOfSquares);
             }
 
             // Sum(X * Y) / (|X| * |Y|)
             return
                 dotProduct /
-                (MathF.Sqrt(xSumOfSquares) * MathF.Sqrt(ySumOfSquares));
+                (T.Sqrt(xSumOfSquares) * T.Sqrt(ySumOfSquares));
         }
 
         /// <summary>Performs an aggregation over all elements in <paramref name="x"/> to produce a single-precision floating-point value.</summary>
+        /// <typeparam name="T">The element type.</typeparam>
         /// <typeparam name="TTransformOperator">Specifies the transform operation that should be applied to each element loaded from <paramref name="x"/>.</typeparam>
         /// <typeparam name="TAggregationOperator">
         /// Specifies the aggregation binary operation that should be applied to multiple values to aggregate them into a single value.
         /// The aggregation is applied after the transform is applied to each element.
         /// </typeparam>
-        private static float Aggregate<TTransformOperator, TAggregationOperator>(
-            ReadOnlySpan<float> x)
-            where TTransformOperator : struct, IUnaryOperator
-            where TAggregationOperator : struct, IAggregationOperator
+        private static T Aggregate<T, TTransformOperator, TAggregationOperator>(
+            ReadOnlySpan<T> x)
+            where TTransformOperator : struct, IUnaryOperator<T>
+            where TAggregationOperator : struct, IAggregationOperator<T>
         {
             // 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 float xRef = ref MemoryMarshal.GetReference(x);
+            ref T xRef = ref MemoryMarshal.GetReference(x);
 
-            nuint remainder = (uint)(x.Length);
+            nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TTransformOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
-                float result;
+                T result;
 
-                if (remainder >= (uint)(Vector512<float>.Count))
+                if (remainder >= (uint)Vector512<T>.Count)
                 {
                     result = Vectorized512(ref xRef, remainder);
                 }
@@ -825,11 +833,11 @@ private static float Aggregate<TTransformOperator, TAggregationOperator>(
                 return result;
             }
 
-            if (Vector256.IsHardwareAccelerated)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TTransformOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
-                float result;
+                T result;
 
-                if (remainder >= (uint)(Vector256<float>.Count))
+                if (remainder >= (uint)Vector256<T>.Count)
                 {
                     result = Vectorized256(ref xRef, remainder);
                 }
@@ -845,11 +853,11 @@ private static float Aggregate<TTransformOperator, TAggregationOperator>(
                 return result;
             }
 
-            if (Vector128.IsHardwareAccelerated)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && TTransformOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
-                float result;
+                T result;
 
-                if (remainder >= (uint)(Vector128<float>.Count))
+                if (remainder >= (uint)Vector128<T>.Count)
                 {
                     result = Vectorized128(ref xRef, remainder);
                 }
@@ -871,9 +879,9 @@ private static float Aggregate<TTransformOperator, TAggregationOperator>(
             return SoftwareFallback(ref xRef, remainder);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static float SoftwareFallback(ref float xRef, nuint length)
+            static T SoftwareFallback(ref T xRef, nuint length)
             {
-                float result = TAggregationOperator.IdentityValue;
+                T result = TAggregationOperator.IdentityValue;
 
                 for (nuint i = 0; i < length; i++)
                 {
@@ -883,31 +891,31 @@ static float SoftwareFallback(ref float xRef, nuint length)
                 return result;
             }
 
-            static float Vectorized128(ref float xRef, nuint remainder)
+            static T Vectorized128(ref T xRef, nuint remainder)
             {
-                Vector128<float> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
+                Vector128<T> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector128<float> beg = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
-                Vector128<float> end = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)));
+                Vector128<T> beg = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                Vector128<T> end = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count));
 
                 nuint misalignment = 0;
 
-                if (remainder > (uint)(Vector128<float>.Count * 8))
+                if (remainder > (uint)(Vector128<T>.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 (float* px = &xRef)
+                    fixed (T* px = &xRef)
                     {
-                        float* xPtr = px;
+                        T* xPtr = px;
 
                         // 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)(xPtr) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -917,30 +925,30 @@ static float Vectorized128(ref float xRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            misalignment = ((uint)(sizeof(Vector128<float>)) - ((nuint)(xPtr) % (uint)(sizeof(Vector128<float>)))) / sizeof(float);
+                            misalignment = ((uint)sizeof(Vector128<T>) - ((nuint)xPtr % (uint)sizeof(Vector128<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
 
-                            Debug.Assert(((nuint)(xPtr) % (uint)(sizeof(Vector128<float>))) == 0);
+                            Debug.Assert(((nuint)xPtr % (uint)sizeof(Vector128<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector128<float> vector1;
-                        Vector128<float> vector2;
-                        Vector128<float> vector3;
-                        Vector128<float> vector4;
+                        Vector128<T> vector1;
+                        Vector128<T> vector2;
+                        Vector128<T> vector3;
+                        Vector128<T> vector4;
 
                         // We only need to load, so there isn't a lot of benefit to doing non-temporal operations
 
-                        while (remainder >= (uint)(Vector128<float>.Count * 8))
+                        while (remainder >= (uint)(Vector128<T>.Count * 8))
                         {
                             // We load, process, and store the first four vectors
 
-                            vector1 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)));
-                            vector2 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)));
-                            vector3 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)));
-                            vector4 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)));
+                            vector1 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)));
+                            vector2 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)));
+                            vector3 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)));
+                            vector4 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -949,10 +957,10 @@ static float Vectorized128(ref float xRef, nuint remainder)
 
                             // We load, process, and store the next four vectors
 
-                            vector1 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)));
-                            vector2 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)));
-                            vector3 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)));
-                            vector4 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)));
+                            vector1 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)));
+                            vector2 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)));
+                            vector3 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)));
+                            vector4 = TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -962,9 +970,9 @@ static float Vectorized128(ref float xRef, nuint remainder)
                             // We adjust the source and destination references, then update
                             // the count of remaining elements to process.
 
-                            xPtr += (uint)(Vector128<float>.Count * 8);
+                            xPtr += (uint)(Vector128<T>.Count * 8);
 
-                            remainder -= (uint)(Vector128<float>.Count * 8);
+                            remainder -= (uint)(Vector128<T>.Count * 8);
                         }
 
                         // Adjusting the refs here allows us to avoid pinning for very small inputs
@@ -976,7 +984,7 @@ static float Vectorized128(ref float xRef, nuint remainder)
                 // Store the first block. Handling this separately simplifies the latter code as we know
                 // they come after and so we can relegate it to full blocks or the trailing elements
 
-                beg = Vector128.ConditionalSelect(CreateAlignmentMaskSingleVector128((int)(misalignment)), beg, Vector128.Create(TAggregationOperator.IdentityValue));
+                beg = Vector128.ConditionalSelect(CreateAlignmentMaskVector128<T>((int)misalignment), beg, Vector128.Create(TAggregationOperator.IdentityValue));
                 vresult = TAggregationOperator.Invoke(vresult, beg);
 
                 // Process the remaining [0, Count * 7] elements via a jump table
@@ -985,7 +993,7 @@ static float Vectorized128(ref float xRef, nuint remainder)
                 // worst case end up just doing the identity operation here if there
                 // were no trailing elements.
 
-                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)(Vector128<float>.Count));
+                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector128<T>.Count);
                 blocks -= (misalignment == 0) ? 1u : 0u;
                 remainder -= trailing;
 
@@ -993,49 +1001,49 @@ static float Vectorized128(ref float xRef, nuint remainder)
                 {
                     case 7:
                     {
-                        Vector128<float> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 7)));
+                        Vector128<T> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 7)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector128<float> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 6)));
+                        Vector128<T> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 6)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector128<float> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 5)));
+                        Vector128<T> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 5)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector128<float> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 4)));
+                        Vector128<T> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 4)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector128<float> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 3)));
+                        Vector128<T> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 3)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector128<float> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 2)));
+                        Vector128<T> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 2)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 1;
                     }
 
                     case 1:
                     {
-                        Vector128<float> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 1)));
+                        Vector128<T> vector = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 1)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 0;
                     }
@@ -1043,7 +1051,7 @@ static float Vectorized128(ref float xRef, nuint remainder)
                     case 0:
                     {
                         // Store the last block, which includes any elements that wouldn't fill a full vector
-                        end = Vector128.ConditionalSelect(CreateRemainderMaskSingleVector128((int)(trailing)), end, Vector128.Create(TAggregationOperator.IdentityValue));
+                        end = Vector128.ConditionalSelect(CreateRemainderMaskVector128<T>((int)trailing), end, Vector128.Create(TAggregationOperator.IdentityValue));
                         vresult = TAggregationOperator.Invoke(vresult, end);
                         break;
                     }
@@ -1053,9 +1061,9 @@ static float Vectorized128(ref float xRef, nuint remainder)
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static float Vectorized128Small(ref float xRef, nuint remainder)
+            static T Vectorized128Small(ref T xRef, nuint remainder)
             {
-                float result = TAggregationOperator.IdentityValue;
+                T result = TAggregationOperator.IdentityValue;
 
                 switch (remainder)
                 {
@@ -1086,31 +1094,31 @@ static float Vectorized128Small(ref float xRef, nuint remainder)
                 return result;
             }
 
-            static float Vectorized256(ref float xRef, nuint remainder)
+            static T Vectorized256(ref T xRef, nuint remainder)
             {
-                Vector256<float> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
+                Vector256<T> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector256<float> beg = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
-                Vector256<float> end = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)));
+                Vector256<T> beg = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
+                Vector256<T> end = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count));
 
                 nuint misalignment = 0;
 
-                if (remainder > (uint)(Vector256<float>.Count * 8))
+                if (remainder > (uint)(Vector256<T>.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 (float* px = &xRef)
+                    fixed (T* px = &xRef)
                     {
-                        float* xPtr = px;
+                        T* xPtr = px;
 
                         // 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)(xPtr) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -1120,30 +1128,30 @@ static float Vectorized256(ref float xRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            misalignment = ((uint)(sizeof(Vector256<float>)) - ((nuint)(xPtr) % (uint)(sizeof(Vector256<float>)))) / sizeof(float);
+                            misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)xPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
 
-                            Debug.Assert(((nuint)(xPtr) % (uint)(sizeof(Vector256<float>))) == 0);
+                            Debug.Assert(((nuint)xPtr % (uint)sizeof(Vector256<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector256<float> vector1;
-                        Vector256<float> vector2;
-                        Vector256<float> vector3;
-                        Vector256<float> vector4;
+                        Vector256<T> vector1;
+                        Vector256<T> vector2;
+                        Vector256<T> vector3;
+                        Vector256<T> vector4;
 
                         // We only need to load, so there isn't a lot of benefit to doing non-temporal operations
 
-                        while (remainder >= (uint)(Vector256<float>.Count * 8))
+                        while (remainder >= (uint)(Vector256<T>.Count * 8))
                         {
                             // We load, process, and store the first four vectors
 
-                            vector1 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)));
-                            vector2 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)));
-                            vector3 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)));
-                            vector4 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)));
+                            vector1 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)));
+                            vector2 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)));
+                            vector3 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)));
+                            vector4 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -1152,10 +1160,10 @@ static float Vectorized256(ref float xRef, nuint remainder)
 
                             // We load, process, and store the next four vectors
 
-                            vector1 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)));
-                            vector2 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)));
-                            vector3 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)));
-                            vector4 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)));
+                            vector1 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)));
+                            vector2 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)));
+                            vector3 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)));
+                            vector4 = TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -1165,9 +1173,9 @@ static float Vectorized256(ref float xRef, nuint remainder)
                             // We adjust the source and destination references, then update
                             // the count of remaining elements to process.
 
-                            xPtr += (uint)(Vector256<float>.Count * 8);
+                            xPtr += (uint)(Vector256<T>.Count * 8);
 
-                            remainder -= (uint)(Vector256<float>.Count * 8);
+                            remainder -= (uint)(Vector256<T>.Count * 8);
                         }
 
                         // Adjusting the refs here allows us to avoid pinning for very small inputs
@@ -1179,7 +1187,7 @@ static float Vectorized256(ref float xRef, nuint remainder)
                 // Store the first block. Handling this separately simplifies the latter code as we know
                 // they come after and so we can relegate it to full blocks or the trailing elements
 
-                beg = Vector256.ConditionalSelect(CreateAlignmentMaskSingleVector256((int)(misalignment)), beg, Vector256.Create(TAggregationOperator.IdentityValue));
+                beg = Vector256.ConditionalSelect(CreateAlignmentMaskVector256<T>((int)misalignment), beg, Vector256.Create(TAggregationOperator.IdentityValue));
                 vresult = TAggregationOperator.Invoke(vresult, beg);
 
                 // Process the remaining [0, Count * 7] elements via a jump table
@@ -1188,7 +1196,7 @@ static float Vectorized256(ref float xRef, nuint remainder)
                 // worst case end up just doing the identity operation here if there
                 // were no trailing elements.
 
-                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)(Vector256<float>.Count));
+                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector256<T>.Count);
                 blocks -= (misalignment == 0) ? 1u : 0u;
                 remainder -= trailing;
 
@@ -1196,49 +1204,49 @@ static float Vectorized256(ref float xRef, nuint remainder)
                 {
                     case 7:
                     {
-                        Vector256<float> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 7)));
+                        Vector256<T> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector256<float> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 6)));
+                        Vector256<T> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector256<float> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 5)));
+                        Vector256<T> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector256<float> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 4)));
+                        Vector256<T> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector256<float> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 3)));
+                        Vector256<T> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector256<float> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 2)));
+                        Vector256<T> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 1;
                     }
 
                     case 1:
                     {
-                        Vector256<float> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 1)));
+                        Vector256<T> vector = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 1)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 0;
                     }
@@ -1246,7 +1254,7 @@ static float Vectorized256(ref float xRef, nuint remainder)
                     case 0:
                     {
                         // Store the last block, which includes any elements that wouldn't fill a full vector
-                        end = Vector256.ConditionalSelect(CreateRemainderMaskSingleVector256((int)(trailing)), end, Vector256.Create(TAggregationOperator.IdentityValue));
+                        end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)trailing), end, Vector256.Create(TAggregationOperator.IdentityValue));
                         vresult = TAggregationOperator.Invoke(vresult, end);
                         break;
                     }
@@ -1256,9 +1264,9 @@ static float Vectorized256(ref float xRef, nuint remainder)
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static float Vectorized256Small(ref float xRef, nuint remainder)
+            static T Vectorized256Small(ref T xRef, nuint remainder)
             {
-                float result = TAggregationOperator.IdentityValue;
+                T result = TAggregationOperator.IdentityValue;
 
                 switch (remainder)
                 {
@@ -1267,12 +1275,12 @@ static float Vectorized256Small(ref float xRef, nuint remainder)
                     case 5:
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
-                        Vector128<float> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
+                        Vector128<T> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
 
-                        Vector128<float> beg = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
-                        Vector128<float> end = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)));
+                        Vector128<T> beg = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<T> end = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count));
 
-                        end = Vector128.ConditionalSelect(CreateRemainderMaskSingleVector128((int)(remainder % (uint)(Vector128<float>.Count))), end, Vector128.Create(TAggregationOperator.IdentityValue));
+                        end = Vector128.ConditionalSelect(CreateRemainderMaskVector128<T>((int)(remainder % (uint)Vector128<T>.Count)), end, Vector128.Create(TAggregationOperator.IdentityValue));
 
                         vresult = TAggregationOperator.Invoke(vresult, beg);
                         vresult = TAggregationOperator.Invoke(vresult, end);
@@ -1284,9 +1292,9 @@ static float Vectorized256Small(ref float xRef, nuint remainder)
                     case 4:
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
-                        Vector128<float> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
+                        Vector128<T> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
 
-                        Vector128<float> beg = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<T> beg = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
                         vresult = TAggregationOperator.Invoke(vresult, beg);
 
                         result = TAggregationOperator.Invoke(vresult);
@@ -1320,31 +1328,31 @@ static float Vectorized256Small(ref float xRef, nuint remainder)
                 return result;
             }
 
-            static float Vectorized512(ref float xRef, nuint remainder)
+            static T Vectorized512(ref T xRef, nuint remainder)
             {
-                Vector512<float> vresult = Vector512.Create(TAggregationOperator.IdentityValue);
+                Vector512<T> vresult = Vector512.Create(TAggregationOperator.IdentityValue);
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector512<float> beg = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef));
-                Vector512<float> end = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count)));
+                Vector512<T> beg = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef));
+                Vector512<T> end = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count));
 
                 nuint misalignment = 0;
 
-                if (remainder > (uint)(Vector512<float>.Count * 8))
+                if (remainder > (uint)(Vector512<T>.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 (float* px = &xRef)
+                    fixed (T* px = &xRef)
                     {
-                        float* xPtr = px;
+                        T* xPtr = px;
 
                         // 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)(xPtr) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -1354,30 +1362,30 @@ static float Vectorized512(ref float xRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            misalignment = ((uint)(sizeof(Vector512<float>)) - ((nuint)(xPtr) % (uint)(sizeof(Vector512<float>)))) / sizeof(float);
+                            misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)xPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
 
-                            Debug.Assert(((nuint)(xPtr) % (uint)(sizeof(Vector512<float>))) == 0);
+                            Debug.Assert(((nuint)xPtr % (uint)sizeof(Vector512<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector512<float> vector1;
-                        Vector512<float> vector2;
-                        Vector512<float> vector3;
-                        Vector512<float> vector4;
+                        Vector512<T> vector1;
+                        Vector512<T> vector2;
+                        Vector512<T> vector3;
+                        Vector512<T> vector4;
 
                         // We only need to load, so there isn't a lot of benefit to doing non-temporal operations
 
-                        while (remainder >= (uint)(Vector512<float>.Count * 8))
+                        while (remainder >= (uint)(Vector512<T>.Count * 8))
                         {
                             // We load, process, and store the first four vectors
 
-                            vector1 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)));
-                            vector2 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)));
-                            vector3 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)));
-                            vector4 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)));
+                            vector1 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)));
+                            vector2 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)));
+                            vector3 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)));
+                            vector4 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -1386,10 +1394,10 @@ static float Vectorized512(ref float xRef, nuint remainder)
 
                             // We load, process, and store the next four vectors
 
-                            vector1 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)));
-                            vector2 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)));
-                            vector3 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)));
-                            vector4 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)));
+                            vector1 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)));
+                            vector2 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)));
+                            vector3 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)));
+                            vector4 = TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -1399,9 +1407,9 @@ static float Vectorized512(ref float xRef, nuint remainder)
                             // We adjust the source and destination references, then update
                             // the count of remaining elements to process.
 
-                            xPtr += (uint)(Vector512<float>.Count * 8);
+                            xPtr += (uint)(Vector512<T>.Count * 8);
 
-                            remainder -= (uint)(Vector512<float>.Count * 8);
+                            remainder -= (uint)(Vector512<T>.Count * 8);
                         }
 
                         // Adjusting the refs here allows us to avoid pinning for very small inputs
@@ -1413,7 +1421,7 @@ static float Vectorized512(ref float xRef, nuint remainder)
                 // Store the first block. Handling this separately simplifies the latter code as we know
                 // they come after and so we can relegate it to full blocks or the trailing elements
 
-                beg = Vector512.ConditionalSelect(CreateAlignmentMaskSingleVector512((int)(misalignment)), beg, Vector512.Create(TAggregationOperator.IdentityValue));
+                beg = Vector512.ConditionalSelect(CreateAlignmentMaskVector512<T>((int)misalignment), beg, Vector512.Create(TAggregationOperator.IdentityValue));
                 vresult = TAggregationOperator.Invoke(vresult, beg);
 
                 // Process the remaining [0, Count * 7] elements via a jump table
@@ -1422,7 +1430,7 @@ static float Vectorized512(ref float xRef, nuint remainder)
                 // worst case end up just doing the identity operation here if there
                 // were no trailing elements.
 
-                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)(Vector512<float>.Count));
+                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector512<T>.Count);
                 blocks -= (misalignment == 0) ? 1u : 0u;
                 remainder -= trailing;
 
@@ -1430,49 +1438,49 @@ static float Vectorized512(ref float xRef, nuint remainder)
                 {
                     case 7:
                     {
-                        Vector512<float> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 7)));
+                        Vector512<T> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector512<float> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 6)));
+                        Vector512<T> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector512<float> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 5)));
+                        Vector512<T> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector512<float> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 4)));
+                        Vector512<T> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector512<float> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 3)));
+                        Vector512<T> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector512<float> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 2)));
+                        Vector512<T> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 1;
                     }
 
                     case 1:
                     {
-                        Vector512<float> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 1)));
+                        Vector512<T> vector = TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 1)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 0;
                     }
@@ -1480,7 +1488,7 @@ static float Vectorized512(ref float xRef, nuint remainder)
                     case 0:
                     {
                         // Store the last block, which includes any elements that wouldn't fill a full vector
-                        end = Vector512.ConditionalSelect(CreateRemainderMaskSingleVector512((int)(trailing)), end, Vector512.Create(TAggregationOperator.IdentityValue));
+                        end = Vector512.ConditionalSelect(CreateRemainderMaskVector512<T>((int)trailing), end, Vector512.Create(TAggregationOperator.IdentityValue));
                         vresult = TAggregationOperator.Invoke(vresult, end);
                         break;
                     }
@@ -1490,9 +1498,9 @@ static float Vectorized512(ref float xRef, nuint remainder)
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static float Vectorized512Small(ref float xRef, nuint remainder)
+            static T Vectorized512Small(ref T xRef, nuint remainder)
             {
-                float result = TAggregationOperator.IdentityValue;
+                T result = TAggregationOperator.IdentityValue;
 
                 switch (remainder)
                 {
@@ -1505,12 +1513,12 @@ static float Vectorized512Small(ref float xRef, nuint remainder)
                     case 9:
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
-                        Vector256<float> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
+                        Vector256<T> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
 
-                        Vector256<float> beg = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
-                        Vector256<float> end = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)));
+                        Vector256<T> beg = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
+                        Vector256<T> end = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count));
 
-                        end = Vector256.ConditionalSelect(CreateRemainderMaskSingleVector256((int)(remainder % (uint)(Vector256<float>.Count))), end, Vector256.Create(TAggregationOperator.IdentityValue));
+                        end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue));
 
                         vresult = TAggregationOperator.Invoke(vresult, beg);
                         vresult = TAggregationOperator.Invoke(vresult, end);
@@ -1522,9 +1530,9 @@ static float Vectorized512Small(ref float xRef, nuint remainder)
                     case 8:
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
-                        Vector256<float> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
+                        Vector256<T> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
 
-                        Vector256<float> beg = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
+                        Vector256<T> beg = TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
                         vresult = TAggregationOperator.Invoke(vresult, beg);
 
                         result = TAggregationOperator.Invoke(vresult);
@@ -1536,12 +1544,12 @@ static float Vectorized512Small(ref float xRef, nuint remainder)
                     case 5:
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
-                        Vector128<float> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
+                        Vector128<T> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
 
-                        Vector128<float> beg = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
-                        Vector128<float> end = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)));
+                        Vector128<T> beg = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<T> end = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count));
 
-                        end = Vector128.ConditionalSelect(CreateRemainderMaskSingleVector128((int)(remainder % (uint)(Vector128<float>.Count))), end, Vector128.Create(TAggregationOperator.IdentityValue));
+                        end = Vector128.ConditionalSelect(CreateRemainderMaskVector128<T>((int)(remainder % (uint)Vector128<T>.Count)), end, Vector128.Create(TAggregationOperator.IdentityValue));
 
                         vresult = TAggregationOperator.Invoke(vresult, beg);
                         vresult = TAggregationOperator.Invoke(vresult, end);
@@ -1553,9 +1561,9 @@ static float Vectorized512Small(ref float xRef, nuint remainder)
                     case 4:
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
-                        Vector128<float> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
+                        Vector128<T> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
 
-                        Vector128<float> beg = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<T> beg = TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
                         vresult = TAggregationOperator.Invoke(vresult, beg);
 
                         result = TAggregationOperator.Invoke(vresult);
@@ -1591,15 +1599,16 @@ static float Vectorized512Small(ref float xRef, nuint remainder)
         }
 
         /// <summary>Performs an aggregation over all pair-wise elements in <paramref name="x"/> and <paramref name="y"/> to produce a single-precision floating-point value.</summary>
+        /// <typeparam name="T">The element type.</typeparam>
         /// <typeparam name="TBinaryOperator">Specifies the binary operation that should be applied to the pair-wise elements loaded from <paramref name="x"/> and <paramref name="y"/>.</typeparam>
         /// <typeparam name="TAggregationOperator">
         /// Specifies the aggregation binary operation that should be applied to multiple values to aggregate them into a single value.
         /// The aggregation is applied to the results of the binary operations on the pair-wise values.
         /// </typeparam>
-        private static float Aggregate<TBinaryOperator, TAggregationOperator>(
-            ReadOnlySpan<float> x, ReadOnlySpan<float> y)
-            where TBinaryOperator : struct, IBinaryOperator
-            where TAggregationOperator : struct, IAggregationOperator
+        private static T Aggregate<T, TBinaryOperator, TAggregationOperator>(
+            ReadOnlySpan<T> x, ReadOnlySpan<T> y)
+            where TBinaryOperator : struct, IBinaryOperator<T>
+            where TAggregationOperator : struct, IAggregationOperator<T>
         {
             if (x.Length != y.Length)
             {
@@ -1611,16 +1620,16 @@ private static float Aggregate<TBinaryOperator, TAggregationOperator>(
             // in a way that allows us to have the minimum possible
             // for small sizes
 
-            ref float xRef = ref MemoryMarshal.GetReference(x);
-            ref float yRef = ref MemoryMarshal.GetReference(y);
+            ref T xRef = ref MemoryMarshal.GetReference(x);
+            ref T yRef = ref MemoryMarshal.GetReference(y);
 
-            nuint remainder = (uint)(x.Length);
+            nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                float result;
+                T result;
 
-                if (remainder >= (uint)(Vector512<float>.Count))
+                if (remainder >= (uint)Vector512<T>.Count)
                 {
                     result = Vectorized512(ref xRef, ref yRef, remainder);
                 }
@@ -1636,11 +1645,11 @@ private static float Aggregate<TBinaryOperator, TAggregationOperator>(
                 return result;
             }
 
-            if (Vector256.IsHardwareAccelerated)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                float result;
+                T result;
 
-                if (remainder >= (uint)(Vector256<float>.Count))
+                if (remainder >= (uint)Vector256<T>.Count)
                 {
                     result = Vectorized256(ref xRef, ref yRef, remainder);
                 }
@@ -1656,11 +1665,11 @@ private static float Aggregate<TBinaryOperator, TAggregationOperator>(
                 return result;
             }
 
-            if (Vector128.IsHardwareAccelerated)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                float result;
+                T result;
 
-                if (remainder >= (uint)(Vector128<float>.Count))
+                if (remainder >= (uint)Vector128<T>.Count)
                 {
                     result = Vectorized128(ref xRef, ref yRef, remainder);
                 }
@@ -1682,9 +1691,9 @@ private static float Aggregate<TBinaryOperator, TAggregationOperator>(
             return SoftwareFallback(ref xRef, ref yRef, remainder);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static float SoftwareFallback(ref float xRef, ref float yRef, nuint length)
+            static T SoftwareFallback(ref T xRef, ref T yRef, nuint length)
             {
-                float result = TAggregationOperator.IdentityValue;
+                T result = TAggregationOperator.IdentityValue;
 
                 for (nuint i = 0; i < length; i++)
                 {
@@ -1695,35 +1704,35 @@ static float SoftwareFallback(ref float xRef, ref float yRef, nuint length)
                 return result;
             }
 
-            static float Vectorized128(ref float xRef, ref float yRef, nuint remainder)
+            static T Vectorized128(ref T xRef, ref T yRef, nuint remainder)
             {
-                Vector128<float> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
+                Vector128<T> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector128<float> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                              Vector128.LoadUnsafe(ref yRef));
-                Vector128<float> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                              Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)));
+                Vector128<T> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                          Vector128.LoadUnsafe(ref yRef));
+                Vector128<T> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
+                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count));
 
                 nuint misalignment = 0;
 
-                if (remainder > (uint)(Vector128<float>.Count * 8))
+                if (remainder > (uint)(Vector128<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
+                        T* xPtr = px;
+                        T* yPtr = py;
 
                         // 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)(xPtr) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -1733,35 +1742,35 @@ static float Vectorized128(ref float xRef, ref float yRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            misalignment = ((uint)(sizeof(Vector128<float>)) - ((nuint)(xPtr) % (uint)(sizeof(Vector128<float>)))) / sizeof(float);
+                            misalignment = ((uint)sizeof(Vector128<T>) - ((nuint)xPtr % (uint)sizeof(Vector128<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
 
-                            Debug.Assert(((nuint)(xPtr) % (uint)(sizeof(Vector128<float>))) == 0);
+                            Debug.Assert(((nuint)xPtr % (uint)sizeof(Vector128<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector128<float> vector1;
-                        Vector128<float> vector2;
-                        Vector128<float> vector3;
-                        Vector128<float> vector4;
+                        Vector128<T> vector1;
+                        Vector128<T> vector2;
+                        Vector128<T> vector3;
+                        Vector128<T> vector4;
 
                         // We only need to load, so there isn't a lot of benefit to doing non-temporal operations
 
-                        while (remainder >= (uint)(Vector128<float>.Count * 8))
+                        while (remainder >= (uint)(Vector128<T>.Count * 8))
                         {
                             // We load, process, and store the first four vectors
 
-                            vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)),
-                                                             Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 0)));
-                            vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)),
-                                                             Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 1)));
-                            vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)),
-                                                             Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 2)));
-                            vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)),
-                                                             Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 3)));
+                            vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)),
+                                                             Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 0)));
+                            vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)),
+                                                             Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 1)));
+                            vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)),
+                                                             Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 2)));
+                            vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)),
+                                                             Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 3)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -1770,14 +1779,14 @@ static float Vectorized128(ref float xRef, ref float yRef, nuint remainder)
 
                             // We load, process, and store the next four vectors
 
-                            vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)),
-                                                             Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 4)));
-                            vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)),
-                                                             Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 5)));
-                            vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)),
-                                                             Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 6)));
-                            vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)),
-                                                             Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 7)));
+                            vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)),
+                                                             Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 4)));
+                            vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)),
+                                                             Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 5)));
+                            vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)),
+                                                             Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 6)));
+                            vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)),
+                                                             Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 7)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -1787,10 +1796,10 @@ static float Vectorized128(ref float xRef, ref float yRef, nuint remainder)
                             // We adjust the source and destination references, then update
                             // the count of remaining elements to process.
 
-                            xPtr += (uint)(Vector128<float>.Count * 8);
-                            yPtr += (uint)(Vector128<float>.Count * 8);
+                            xPtr += (uint)(Vector128<T>.Count * 8);
+                            yPtr += (uint)(Vector128<T>.Count * 8);
 
-                            remainder -= (uint)(Vector128<float>.Count * 8);
+                            remainder -= (uint)(Vector128<T>.Count * 8);
                         }
 
                         // Adjusting the refs here allows us to avoid pinning for very small inputs
@@ -1803,7 +1812,7 @@ static float Vectorized128(ref float xRef, ref float yRef, nuint remainder)
                 // Store the first block. Handling this separately simplifies the latter code as we know
                 // they come after and so we can relegate it to full blocks or the trailing elements
 
-                beg = Vector128.ConditionalSelect(CreateAlignmentMaskSingleVector128((int)(misalignment)), beg, Vector128.Create(TAggregationOperator.IdentityValue));
+                beg = Vector128.ConditionalSelect(CreateAlignmentMaskVector128<T>((int)misalignment), beg, Vector128.Create(TAggregationOperator.IdentityValue));
                 vresult = TAggregationOperator.Invoke(vresult, beg);
 
                 // Process the remaining [0, Count * 7] elements via a jump table
@@ -1812,7 +1821,7 @@ static float Vectorized128(ref float xRef, ref float yRef, nuint remainder)
                 // worst case end up just doing the identity operation here if there
                 // were no trailing elements.
 
-                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)(Vector128<float>.Count));
+                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector128<T>.Count);
                 blocks -= (misalignment == 0) ? 1u : 0u;
                 remainder -= trailing;
 
@@ -1820,56 +1829,56 @@ static float Vectorized128(ref float xRef, ref float yRef, nuint remainder)
                 {
                     case 7:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 7)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 7)));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 7)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 7)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 6)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 6)));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 6)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 6)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 5)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 5)));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 5)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 5)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 4)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 4)));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 4)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 4)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 3)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 3)));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 3)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 3)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 2)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 2)));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 2)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 2)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 1;
                     }
 
                     case 1:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 1)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 1)));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 1)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 1)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 0;
                     }
@@ -1877,7 +1886,7 @@ static float Vectorized128(ref float xRef, ref float yRef, nuint remainder)
                     case 0:
                     {
                         // Store the last block, which includes any elements that wouldn't fill a full vector
-                        end = Vector128.ConditionalSelect(CreateRemainderMaskSingleVector128((int)(trailing)), end, Vector128.Create(TAggregationOperator.IdentityValue));
+                        end = Vector128.ConditionalSelect(CreateRemainderMaskVector128<T>((int)trailing), end, Vector128.Create(TAggregationOperator.IdentityValue));
                         vresult = TAggregationOperator.Invoke(vresult, end);
                         break;
                     }
@@ -1887,9 +1896,9 @@ static float Vectorized128(ref float xRef, ref float yRef, nuint remainder)
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static float Vectorized128Small(ref float xRef, ref float yRef, nuint remainder)
+            static T Vectorized128Small(ref T xRef, ref T yRef, nuint remainder)
             {
-                float result = TAggregationOperator.IdentityValue;
+                T result = TAggregationOperator.IdentityValue;
 
                 switch (remainder)
                 {
@@ -1922,35 +1931,35 @@ static float Vectorized128Small(ref float xRef, ref float yRef, nuint remainder)
                 return result;
             }
 
-            static float Vectorized256(ref float xRef, ref float yRef, nuint remainder)
+            static T Vectorized256(ref T xRef, ref T yRef, nuint remainder)
             {
-                Vector256<float> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
+                Vector256<T> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector256<float> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                              Vector256.LoadUnsafe(ref yRef));
-                Vector256<float> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)),
-                                                              Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count)));
+                Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                                                          Vector256.LoadUnsafe(ref yRef));
+                Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
+                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count));
 
                 nuint misalignment = 0;
 
-                if (remainder > (uint)(Vector256<float>.Count * 8))
+                if (remainder > (uint)(Vector256<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
+                        T* xPtr = px;
+                        T* yPtr = py;
 
                         // 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)(xPtr) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -1960,35 +1969,35 @@ static float Vectorized256(ref float xRef, ref float yRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            misalignment = ((uint)(sizeof(Vector256<float>)) - ((nuint)(xPtr) % (uint)(sizeof(Vector256<float>)))) / sizeof(float);
+                            misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)xPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
 
-                            Debug.Assert(((nuint)(xPtr) % (uint)(sizeof(Vector256<float>))) == 0);
+                            Debug.Assert(((nuint)xPtr % (uint)sizeof(Vector256<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector256<float> vector1;
-                        Vector256<float> vector2;
-                        Vector256<float> vector3;
-                        Vector256<float> vector4;
+                        Vector256<T> vector1;
+                        Vector256<T> vector2;
+                        Vector256<T> vector3;
+                        Vector256<T> vector4;
 
                         // We only need to load, so there isn't a lot of benefit to doing non-temporal operations
 
-                        while (remainder >= (uint)(Vector256<float>.Count * 8))
+                        while (remainder >= (uint)(Vector256<T>.Count * 8))
                         {
                             // We load, process, and store the first four vectors
 
-                            vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)),
-                                                             Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 0)));
-                            vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)),
-                                                             Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 1)));
-                            vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)),
-                                                             Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 2)));
-                            vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)),
-                                                             Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 3)));
+                            vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)),
+                                                             Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)));
+                            vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)),
+                                                             Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)));
+                            vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)),
+                                                             Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)));
+                            vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)),
+                                                             Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -1997,14 +2006,14 @@ static float Vectorized256(ref float xRef, ref float yRef, nuint remainder)
 
                             // We load, process, and store the next four vectors
 
-                            vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)),
-                                                             Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 4)));
-                            vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)),
-                                                             Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 5)));
-                            vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)),
-                                                             Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 6)));
-                            vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)),
-                                                             Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 7)));
+                            vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)),
+                                                             Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)));
+                            vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)),
+                                                             Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)));
+                            vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)),
+                                                             Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)));
+                            vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)),
+                                                             Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -2014,10 +2023,10 @@ static float Vectorized256(ref float xRef, ref float yRef, nuint remainder)
                             // We adjust the source and destination references, then update
                             // the count of remaining elements to process.
 
-                            xPtr += (uint)(Vector256<float>.Count * 8);
-                            yPtr += (uint)(Vector256<float>.Count * 8);
+                            xPtr += (uint)(Vector256<T>.Count * 8);
+                            yPtr += (uint)(Vector256<T>.Count * 8);
 
-                            remainder -= (uint)(Vector256<float>.Count * 8);
+                            remainder -= (uint)(Vector256<T>.Count * 8);
                         }
 
                         // Adjusting the refs here allows us to avoid pinning for very small inputs
@@ -2030,7 +2039,7 @@ static float Vectorized256(ref float xRef, ref float yRef, nuint remainder)
                 // Store the first block. Handling this separately simplifies the latter code as we know
                 // they come after and so we can relegate it to full blocks or the trailing elements
 
-                beg = Vector256.ConditionalSelect(CreateAlignmentMaskSingleVector256((int)(misalignment)), beg, Vector256.Create(TAggregationOperator.IdentityValue));
+                beg = Vector256.ConditionalSelect(CreateAlignmentMaskVector256<T>((int)misalignment), beg, Vector256.Create(TAggregationOperator.IdentityValue));
                 vresult = TAggregationOperator.Invoke(vresult, beg);
 
                 // Process the remaining [0, Count * 7] elements via a jump table
@@ -2039,7 +2048,7 @@ static float Vectorized256(ref float xRef, ref float yRef, nuint remainder)
                 // worst case end up just doing the identity operation here if there
                 // were no trailing elements.
 
-                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)(Vector256<float>.Count));
+                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector256<T>.Count);
                 blocks -= (misalignment == 0) ? 1u : 0u;
                 remainder -= trailing;
 
@@ -2047,56 +2056,56 @@ static float Vectorized256(ref float xRef, ref float yRef, nuint remainder)
                 {
                     case 7:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 7)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 7)));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 6)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 6)));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 5)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 5)));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 4)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 4)));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 3)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 3)));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 2)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 2)));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 1;
                     }
 
                     case 1:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 1)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 1)));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 1)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 1)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 0;
                     }
@@ -2104,7 +2113,7 @@ static float Vectorized256(ref float xRef, ref float yRef, nuint remainder)
                     case 0:
                     {
                         // Store the last block, which includes any elements that wouldn't fill a full vector
-                        end = Vector256.ConditionalSelect(CreateRemainderMaskSingleVector256((int)(trailing)), end, Vector256.Create(TAggregationOperator.IdentityValue));
+                        end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)trailing), end, Vector256.Create(TAggregationOperator.IdentityValue));
                         vresult = TAggregationOperator.Invoke(vresult, end);
                         break;
                     }
@@ -2114,9 +2123,9 @@ static float Vectorized256(ref float xRef, ref float yRef, nuint remainder)
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static float Vectorized256Small(ref float xRef, ref float yRef, nuint remainder)
+            static T Vectorized256Small(ref T xRef, ref T yRef, nuint remainder)
             {
-                float result = TAggregationOperator.IdentityValue;
+                T result = TAggregationOperator.IdentityValue;
 
                 switch (remainder)
                 {
@@ -2125,14 +2134,14 @@ static float Vectorized256Small(ref float xRef, ref float yRef, nuint remainder)
                     case 5:
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
-                        Vector128<float> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
+                        Vector128<T> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                      Vector128.LoadUnsafe(ref yRef));
-                        Vector128<float> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                                      Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)));
+                        Vector128<T> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                  Vector128.LoadUnsafe(ref yRef));
+                        Vector128<T> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
+                                                                  Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count));
 
-                        end = Vector128.ConditionalSelect(CreateRemainderMaskSingleVector128((int)(remainder % (uint)(Vector128<float>.Count))), end, Vector128.Create(TAggregationOperator.IdentityValue));
+                        end = Vector128.ConditionalSelect(CreateRemainderMaskVector128<T>((int)(remainder % (uint)Vector128<T>.Count)), end, Vector128.Create(TAggregationOperator.IdentityValue));
 
                         vresult = TAggregationOperator.Invoke(vresult, beg);
                         vresult = TAggregationOperator.Invoke(vresult, end);
@@ -2144,10 +2153,10 @@ static float Vectorized256Small(ref float xRef, ref float yRef, nuint remainder)
                     case 4:
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
-                        Vector128<float> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
+                        Vector128<T> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                      Vector128.LoadUnsafe(ref yRef));
+                        Vector128<T> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                  Vector128.LoadUnsafe(ref yRef));
                         vresult = TAggregationOperator.Invoke(vresult, beg);
 
                         result = TAggregationOperator.Invoke(vresult);
@@ -2183,35 +2192,35 @@ static float Vectorized256Small(ref float xRef, ref float yRef, nuint remainder)
                 return result;
             }
 
-            static float Vectorized512(ref float xRef, ref float yRef, nuint remainder)
+            static T Vectorized512(ref T xRef, ref T yRef, nuint remainder)
             {
-                Vector512<float> vresult = Vector512.Create(TAggregationOperator.IdentityValue);
+                Vector512<T> vresult = Vector512.Create(TAggregationOperator.IdentityValue);
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector512<float> beg = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef),
-                                                              Vector512.LoadUnsafe(ref yRef));
-                Vector512<float> end = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count)),
-                                                              Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count)));
+                Vector512<T> beg = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef),
+                                                          Vector512.LoadUnsafe(ref yRef));
+                Vector512<T> end = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count),
+                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count));
 
                 nuint misalignment = 0;
 
-                if (remainder > (uint)(Vector512<float>.Count * 8))
+                if (remainder > (uint)(Vector512<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
+                        T* xPtr = px;
+                        T* yPtr = py;
 
                         // 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)(xPtr) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -2221,35 +2230,35 @@ static float Vectorized512(ref float xRef, ref float yRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            misalignment = ((uint)(sizeof(Vector512<float>)) - ((nuint)(xPtr) % (uint)(sizeof(Vector512<float>)))) / sizeof(float);
+                            misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)xPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
 
-                            Debug.Assert(((nuint)(xPtr) % (uint)(sizeof(Vector512<float>))) == 0);
+                            Debug.Assert(((nuint)xPtr % (uint)sizeof(Vector512<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector512<float> vector1;
-                        Vector512<float> vector2;
-                        Vector512<float> vector3;
-                        Vector512<float> vector4;
+                        Vector512<T> vector1;
+                        Vector512<T> vector2;
+                        Vector512<T> vector3;
+                        Vector512<T> vector4;
 
                         // We only need to load, so there isn't a lot of benefit to doing non-temporal operations
 
-                        while (remainder >= (uint)(Vector512<float>.Count * 8))
+                        while (remainder >= (uint)(Vector512<T>.Count * 8))
                         {
                             // We load, process, and store the first four vectors
 
-                            vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)),
-                                                             Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 0)));
-                            vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)),
-                                                             Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 1)));
-                            vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)),
-                                                             Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 2)));
-                            vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)),
-                                                             Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 3)));
+                            vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)),
+                                                             Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)));
+                            vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)),
+                                                             Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)));
+                            vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)),
+                                                             Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)));
+                            vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)),
+                                                             Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -2258,14 +2267,14 @@ static float Vectorized512(ref float xRef, ref float yRef, nuint remainder)
 
                             // We load, process, and store the next four vectors
 
-                            vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)),
-                                                             Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 4)));
-                            vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)),
-                                                             Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 5)));
-                            vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)),
-                                                             Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 6)));
-                            vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)),
-                                                             Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 7)));
+                            vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)),
+                                                             Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)));
+                            vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)),
+                                                             Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)));
+                            vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)),
+                                                             Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)));
+                            vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)),
+                                                             Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)));
 
                             vresult = TAggregationOperator.Invoke(vresult, vector1);
                             vresult = TAggregationOperator.Invoke(vresult, vector2);
@@ -2275,10 +2284,10 @@ static float Vectorized512(ref float xRef, ref float yRef, nuint remainder)
                             // We adjust the source and destination references, then update
                             // the count of remaining elements to process.
 
-                            xPtr += (uint)(Vector512<float>.Count * 8);
-                            yPtr += (uint)(Vector512<float>.Count * 8);
+                            xPtr += (uint)(Vector512<T>.Count * 8);
+                            yPtr += (uint)(Vector512<T>.Count * 8);
 
-                            remainder -= (uint)(Vector512<float>.Count * 8);
+                            remainder -= (uint)(Vector512<T>.Count * 8);
                         }
 
                         // Adjusting the refs here allows us to avoid pinning for very small inputs
@@ -2291,7 +2300,7 @@ static float Vectorized512(ref float xRef, ref float yRef, nuint remainder)
                 // Store the first block. Handling this separately simplifies the latter code as we know
                 // they come after and so we can relegate it to full blocks or the trailing elements
 
-                beg = Vector512.ConditionalSelect(CreateAlignmentMaskSingleVector512((int)(misalignment)), beg, Vector512.Create(TAggregationOperator.IdentityValue));
+                beg = Vector512.ConditionalSelect(CreateAlignmentMaskVector512<T>((int)misalignment), beg, Vector512.Create(TAggregationOperator.IdentityValue));
                 vresult = TAggregationOperator.Invoke(vresult, beg);
 
                 // Process the remaining [0, Count * 7] elements via a jump table
@@ -2300,7 +2309,7 @@ static float Vectorized512(ref float xRef, ref float yRef, nuint remainder)
                 // worst case end up just doing the identity operation here if there
                 // were no trailing elements.
 
-                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)(Vector512<float>.Count));
+                (nuint blocks, nuint trailing) = Math.DivRem(remainder, (nuint)Vector512<T>.Count);
                 blocks -= (misalignment == 0) ? 1u : 0u;
                 remainder -= trailing;
 
@@ -2308,56 +2317,56 @@ static float Vectorized512(ref float xRef, ref float yRef, nuint remainder)
                 {
                     case 7:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 7)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 7)));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 7)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 6)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 6)));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 6)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 5)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 5)));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 5)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 4)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 4)));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 4)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 3)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 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)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 2)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 2)));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 2)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 1;
                     }
 
                     case 1:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 1)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 1)));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 1)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 1)));
                         vresult = TAggregationOperator.Invoke(vresult, vector);
                         goto case 0;
                     }
@@ -2365,7 +2374,7 @@ static float Vectorized512(ref float xRef, ref float yRef, nuint remainder)
                     case 0:
                     {
                         // Store the last block, which includes any elements that wouldn't fill a full vector
-                        end = Vector512.ConditionalSelect(CreateRemainderMaskSingleVector512((int)(trailing)), end, Vector512.Create(TAggregationOperator.IdentityValue));
+                        end = Vector512.ConditionalSelect(CreateRemainderMaskVector512<T>((int)trailing), end, Vector512.Create(TAggregationOperator.IdentityValue));
                         vresult = TAggregationOperator.Invoke(vresult, end);
                         break;
                     }
@@ -2375,9 +2384,9 @@ static float Vectorized512(ref float xRef, ref float yRef, nuint remainder)
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static float Vectorized512Small(ref float xRef, ref float yRef, nuint remainder)
+            static T Vectorized512Small(ref T xRef, ref T yRef, nuint remainder)
             {
-                float result = TAggregationOperator.IdentityValue;
+                T result = TAggregationOperator.IdentityValue;
 
                 switch (remainder)
                 {
@@ -2390,14 +2399,14 @@ static float Vectorized512Small(ref float xRef, ref float yRef, nuint remainder)
                     case 9:
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
-                        Vector256<float> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
+                        Vector256<T> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
 
-                        Vector256<float> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                      Vector256.LoadUnsafe(ref yRef));
-                        Vector256<float> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)),
-                                                                      Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count)));
+                        Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                                                                  Vector256.LoadUnsafe(ref yRef));
+                        Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
+                                                                  Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count));
 
-                        end = Vector256.ConditionalSelect(CreateRemainderMaskSingleVector256((int)(remainder % (uint)(Vector256<float>.Count))), end, Vector256.Create(TAggregationOperator.IdentityValue));
+                        end = Vector256.ConditionalSelect(CreateRemainderMaskVector256<T>((int)(remainder % (uint)Vector256<T>.Count)), end, Vector256.Create(TAggregationOperator.IdentityValue));
 
                         vresult = TAggregationOperator.Invoke(vresult, beg);
                         vresult = TAggregationOperator.Invoke(vresult, end);
@@ -2409,10 +2418,10 @@ static float Vectorized512Small(ref float xRef, ref float yRef, nuint remainder)
                     case 8:
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
-                        Vector256<float> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
+                        Vector256<T> vresult = Vector256.Create(TAggregationOperator.IdentityValue);
 
-                        Vector256<float> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                      Vector256.LoadUnsafe(ref yRef));
+                        Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                                                                  Vector256.LoadUnsafe(ref yRef));
                         vresult = TAggregationOperator.Invoke(vresult, beg);
 
                         result = TAggregationOperator.Invoke(vresult);
@@ -2424,14 +2433,14 @@ static float Vectorized512Small(ref float xRef, ref float yRef, nuint remainder)
                     case 5:
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
-                        Vector128<float> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
+                        Vector128<T> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                      Vector128.LoadUnsafe(ref yRef));
-                        Vector128<float> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                                      Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)));
+                        Vector128<T> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                  Vector128.LoadUnsafe(ref yRef));
+                        Vector128<T> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
+                                                                  Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count));
 
-                        end = Vector128.ConditionalSelect(CreateRemainderMaskSingleVector128((int)(remainder % (uint)(Vector128<float>.Count))), end, Vector128.Create(TAggregationOperator.IdentityValue));
+                        end = Vector128.ConditionalSelect(CreateRemainderMaskVector128<T>((int)(remainder % (uint)Vector128<T>.Count)), end, Vector128.Create(TAggregationOperator.IdentityValue));
 
                         vresult = TAggregationOperator.Invoke(vresult, beg);
                         vresult = TAggregationOperator.Invoke(vresult, end);
@@ -2443,10 +2452,10 @@ static float Vectorized512Small(ref float xRef, ref float yRef, nuint remainder)
                     case 4:
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
-                        Vector128<float> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
+                        Vector128<T> vresult = Vector128.Create(TAggregationOperator.IdentityValue);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                      Vector128.LoadUnsafe(ref yRef));
+                        Vector128<T> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                  Vector128.LoadUnsafe(ref yRef));
                         vresult = TAggregationOperator.Invoke(vresult, beg);
 
                         result = TAggregationOperator.Invoke(vresult);
@@ -2484,11 +2493,12 @@ static float Vectorized512Small(ref float xRef, ref float yRef, nuint remainder)
         }
 
         /// <remarks>
-        /// This is the same as <see cref="Aggregate{TTransformOperator, TAggregationOperator}(ReadOnlySpan{float})"/>
+        /// This is the same as <see cref="Aggregate{T, TTransformOperator, TAggregationOperator}(ReadOnlySpan{T})"/>
         /// with an identity transform, except it early exits on NaN.
         /// </remarks>
-        private static float MinMaxCore<TMinMaxOperator>(ReadOnlySpan<float> x)
-            where TMinMaxOperator : struct, IAggregationOperator
+        private static T MinMaxCore<T, TMinMaxOperator>(ReadOnlySpan<T> x)
+            where T : INumberBase<T>
+            where TMinMaxOperator : struct, IAggregationOperator<T>
         {
             if (x.IsEmpty)
             {
@@ -2500,23 +2510,28 @@ private static float MinMaxCore<TMinMaxOperator>(ReadOnlySpan<float> x)
             // otherwise returns the greater of the inputs.
             // It treats +0 as greater than -0 as per the specification.
 
-            if (Vector512.IsHardwareAccelerated && x.Length >= Vector512<float>.Count)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && x.Length >= Vector512<T>.Count)
             {
-                ref float xRef = ref MemoryMarshal.GetReference(x);
+                ref T xRef = ref MemoryMarshal.GetReference(x);
 
                 // Load the first vector as the initial set of results, and bail immediately
                 // to scalar handling if it contains any NaNs (which don't compare equally to themselves).
-                Vector512<float> result = Vector512.LoadUnsafe(ref xRef, 0);
-                Vector512<float> current;
+                Vector512<T> result = Vector512.LoadUnsafe(ref xRef, 0);
+                Vector512<T> current;
 
-                Vector512<float> nanMask = ~Vector512.Equals(result, result);
-                if (nanMask != Vector512<float>.Zero)
+                Vector512<T> nanMask;
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                 {
-                    return result.GetElement(IndexOfFirstMatch(nanMask));
+                    // Check for NaNs
+                    nanMask = ~Vector512.Equals(result, result);
+                    if (nanMask != Vector512<T>.Zero)
+                    {
+                        return result.GetElement(IndexOfFirstMatch(nanMask));
+                    }
                 }
 
-                int oneVectorFromEnd = x.Length - Vector512<float>.Count;
-                int i = Vector512<float>.Count;
+                int oneVectorFromEnd = x.Length - Vector512<T>.Count;
+                int i = Vector512<T>.Count;
 
                 // Aggregate additional vectors into the result as long as there's at least one full vector left to process.
                 while (i <= oneVectorFromEnd)
@@ -2524,25 +2539,33 @@ private static float MinMaxCore<TMinMaxOperator>(ReadOnlySpan<float> x)
                     // Load the next vector, and early exit on NaN.
                     current = Vector512.LoadUnsafe(ref xRef, (uint)i);
 
-                    nanMask = ~Vector512.Equals(current, current);
-                    if (nanMask != Vector512<float>.Zero)
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return current.GetElement(IndexOfFirstMatch(nanMask));
+                        // Check for NaNs
+                        nanMask = ~Vector512.Equals(current, current);
+                        if (nanMask != Vector512<T>.Zero)
+                        {
+                            return current.GetElement(IndexOfFirstMatch(nanMask));
+                        }
                     }
 
                     result = TMinMaxOperator.Invoke(result, current);
-                    i += Vector512<float>.Count;
+                    i += Vector512<T>.Count;
                 }
 
                 // If any elements remain, handle them in one final vector.
                 if (i != x.Length)
                 {
-                    current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<float>.Count));
+                    current = Vector512.LoadUnsafe(ref xRef, (uint)(x.Length - Vector512<T>.Count));
 
-                    nanMask = ~Vector512.Equals(current, current);
-                    if (nanMask != Vector512<float>.Zero)
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return current.GetElement(IndexOfFirstMatch(nanMask));
+                        // Check for NaNs
+                        nanMask = ~Vector512.Equals(current, current);
+                        if (nanMask != Vector512<T>.Zero)
+                        {
+                            return current.GetElement(IndexOfFirstMatch(nanMask));
+                        }
                     }
 
                     result = TMinMaxOperator.Invoke(result, current);
@@ -2552,23 +2575,28 @@ private static float MinMaxCore<TMinMaxOperator>(ReadOnlySpan<float> x)
                 return TMinMaxOperator.Invoke(result);
             }
 
-            if (Vector256.IsHardwareAccelerated && x.Length >= Vector256<float>.Count)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && x.Length >= Vector256<T>.Count)
             {
-                ref float xRef = ref MemoryMarshal.GetReference(x);
+                ref T xRef = ref MemoryMarshal.GetReference(x);
 
                 // Load the first vector as the initial set of results, and bail immediately
                 // to scalar handling if it contains any NaNs (which don't compare equally to themselves).
-                Vector256<float> result = Vector256.LoadUnsafe(ref xRef, 0);
-                Vector256<float> current;
+                Vector256<T> result = Vector256.LoadUnsafe(ref xRef, 0);
+                Vector256<T> current;
 
-                Vector256<float> nanMask = ~Vector256.Equals(result, result);
-                if (nanMask != Vector256<float>.Zero)
+                Vector256<T> nanMask;
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                 {
-                    return result.GetElement(IndexOfFirstMatch(nanMask));
+                    // Check for NaNs
+                    nanMask = ~Vector256.Equals(result, result);
+                    if (nanMask != Vector256<T>.Zero)
+                    {
+                        return result.GetElement(IndexOfFirstMatch(nanMask));
+                    }
                 }
 
-                int oneVectorFromEnd = x.Length - Vector256<float>.Count;
-                int i = Vector256<float>.Count;
+                int oneVectorFromEnd = x.Length - Vector256<T>.Count;
+                int i = Vector256<T>.Count;
 
                 // Aggregate additional vectors into the result as long as there's at least one full vector left to process.
                 while (i <= oneVectorFromEnd)
@@ -2576,25 +2604,34 @@ private static float MinMaxCore<TMinMaxOperator>(ReadOnlySpan<float> x)
                     // Load the next vector, and early exit on NaN.
                     current = Vector256.LoadUnsafe(ref xRef, (uint)i);
 
-                    nanMask = ~Vector256.Equals(current, current);
-                    if (nanMask != Vector256<float>.Zero)
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return current.GetElement(IndexOfFirstMatch(nanMask));
+                        // Check for NaNs
+                        nanMask = ~Vector256.Equals(current, current);
+                        if (nanMask != Vector256<T>.Zero)
+                        {
+                            return current.GetElement(IndexOfFirstMatch(nanMask));
+                        }
                     }
 
                     result = TMinMaxOperator.Invoke(result, current);
-                    i += Vector256<float>.Count;
+                    i += Vector256<T>.Count;
                 }
 
                 // If any elements remain, handle them in one final vector.
                 if (i != x.Length)
                 {
-                    current = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<float>.Count));
+                    current = Vector256.LoadUnsafe(ref xRef, (uint)(x.Length - Vector256<T>.Count));
 
-                    nanMask = ~Vector256.Equals(current, current);
-                    if (nanMask != Vector256<float>.Zero)
+
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return current.GetElement(IndexOfFirstMatch(nanMask));
+                        // Check for NaNs
+                        nanMask = ~Vector256.Equals(current, current);
+                        if (nanMask != Vector256<T>.Zero)
+                        {
+                            return current.GetElement(IndexOfFirstMatch(nanMask));
+                        }
                     }
 
                     result = TMinMaxOperator.Invoke(result, current);
@@ -2604,23 +2641,28 @@ private static float MinMaxCore<TMinMaxOperator>(ReadOnlySpan<float> x)
                 return TMinMaxOperator.Invoke(result);
             }
 
-            if (Vector128.IsHardwareAccelerated && x.Length >= Vector128<float>.Count)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && x.Length >= Vector128<T>.Count)
             {
-                ref float xRef = ref MemoryMarshal.GetReference(x);
+                ref T xRef = ref MemoryMarshal.GetReference(x);
 
                 // Load the first vector as the initial set of results, and bail immediately
                 // to scalar handling if it contains any NaNs (which don't compare equally to themselves).
-                Vector128<float> result = Vector128.LoadUnsafe(ref xRef, 0);
-                Vector128<float> current;
+                Vector128<T> result = Vector128.LoadUnsafe(ref xRef, 0);
+                Vector128<T> current;
 
-                Vector128<float> nanMask = ~Vector128.Equals(result, result);
-                if (nanMask != Vector128<float>.Zero)
+                Vector128<T> nanMask;
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                 {
-                    return result.GetElement(IndexOfFirstMatch(nanMask));
+                    // Check for NaNs
+                    nanMask = ~Vector128.Equals(result, result);
+                    if (nanMask != Vector128<T>.Zero)
+                    {
+                        return result.GetElement(IndexOfFirstMatch(nanMask));
+                    }
                 }
 
-                int oneVectorFromEnd = x.Length - Vector128<float>.Count;
-                int i = Vector128<float>.Count;
+                int oneVectorFromEnd = x.Length - Vector128<T>.Count;
+                int i = Vector128<T>.Count;
 
                 // Aggregate additional vectors into the result as long as there's at least one full vector left to process.
                 while (i <= oneVectorFromEnd)
@@ -2628,25 +2670,33 @@ private static float MinMaxCore<TMinMaxOperator>(ReadOnlySpan<float> x)
                     // Load the next vector, and early exit on NaN.
                     current = Vector128.LoadUnsafe(ref xRef, (uint)i);
 
-                    nanMask = ~Vector128.Equals(current, current);
-                    if (nanMask != Vector128<float>.Zero)
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return current.GetElement(IndexOfFirstMatch(nanMask));
+                        // Check for NaNs
+                        nanMask = ~Vector128.Equals(current, current);
+                        if (nanMask != Vector128<T>.Zero)
+                        {
+                            return current.GetElement(IndexOfFirstMatch(nanMask));
+                        }
                     }
 
                     result = TMinMaxOperator.Invoke(result, current);
-                    i += Vector128<float>.Count;
+                    i += Vector128<T>.Count;
                 }
 
                 // If any elements remain, handle them in one final vector.
                 if (i != x.Length)
                 {
-                    current = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<float>.Count));
+                    current = Vector128.LoadUnsafe(ref xRef, (uint)(x.Length - Vector128<T>.Count));
 
-                    nanMask = ~Vector128.Equals(current, current);
-                    if (nanMask != Vector128<float>.Zero)
+                    if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
                     {
-                        return current.GetElement(IndexOfFirstMatch(nanMask));
+                        // Check for NaNs
+                        nanMask = ~Vector128.Equals(current, current);
+                        if (nanMask != Vector128<T>.Zero)
+                        {
+                            return current.GetElement(IndexOfFirstMatch(nanMask));
+                        }
                     }
 
                     result = TMinMaxOperator.Invoke(result, current);
@@ -2657,16 +2707,16 @@ private static float MinMaxCore<TMinMaxOperator>(ReadOnlySpan<float> x)
             }
 
             // Scalar path used when either vectorization is not supported or the input is too small to vectorize.
-            float curResult = x[0];
-            if (float.IsNaN(curResult))
+            T curResult = x[0];
+            if (T.IsNaN(curResult))
             {
                 return curResult;
             }
 
             for (int i = 1; i < x.Length; i++)
             {
-                float current = x[i];
-                if (float.IsNaN(current))
+                T current = x[i];
+                if (T.IsNaN(current))
                 {
                     return current;
                 }
@@ -2677,7 +2727,8 @@ private static float MinMaxCore<TMinMaxOperator>(ReadOnlySpan<float> x)
             return curResult;
         }
 
-        private static int IndexOfMinMaxCore<TIndexOfMinMax>(ReadOnlySpan<float> x) where TIndexOfMinMax : struct, IIndexOfOperator
+        private static int IndexOfMinMaxCore<TIndexOfMinMax>(ReadOnlySpan<float> x)
+            where TIndexOfMinMax : struct, IIndexOfOperator
         {
             if (x.IsEmpty)
             {
@@ -2886,26 +2937,27 @@ private static int IndexOfMinMaxCore<TIndexOfMinMax>(ReadOnlySpan<float> x) wher
             return curIn;
         }
 
-        private static int IndexOfFirstMatch(Vector128<float> mask)
+        private static int IndexOfFirstMatch<T>(Vector128<T> mask)
         {
             return BitOperations.TrailingZeroCount(mask.ExtractMostSignificantBits());
         }
 
-        private static int IndexOfFirstMatch(Vector256<float> mask)
+        private static int IndexOfFirstMatch<T>(Vector256<T> mask)
         {
             return BitOperations.TrailingZeroCount(mask.ExtractMostSignificantBits());
         }
 
-        private static int IndexOfFirstMatch(Vector512<float> mask)
+        private static int IndexOfFirstMatch<T>(Vector512<T> mask)
         {
             return 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="TUnaryOperator">Specifies the operation to perform on each element loaded from <paramref name="x"/>.</typeparam>
-        private static void InvokeSpanIntoSpan<TUnaryOperator>(
-            ReadOnlySpan<float> x, Span<float> destination)
-            where TUnaryOperator : struct, IUnaryOperator
+        private static void InvokeSpanIntoSpan<T, TUnaryOperator>(
+            ReadOnlySpan<T> x, Span<T> destination)
+            where TUnaryOperator : struct, IUnaryOperator<T>
         {
             if (x.Length > destination.Length)
             {
@@ -2919,14 +2971,14 @@ private static void InvokeSpanIntoSpan<TUnaryOperator>(
             // in a way that allows us to have the minimum possible
             // for small sizes
 
-            ref float xRef = ref MemoryMarshal.GetReference(x);
-            ref float dRef = ref MemoryMarshal.GetReference(destination);
+            ref T xRef = ref MemoryMarshal.GetReference(x);
+            ref T dRef = ref MemoryMarshal.GetReference(destination);
 
-            nuint remainder = (uint)(x.Length);
+            nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TUnaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector512<float>.Count))
+                if (remainder >= (uint)Vector512<T>.Count)
                 {
                     Vectorized512(ref xRef, ref dRef, remainder);
                 }
@@ -2942,9 +2994,9 @@ private static void InvokeSpanIntoSpan<TUnaryOperator>(
                 return;
             }
 
-            if (Vector256.IsHardwareAccelerated)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TUnaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector256<float>.Count))
+                if (remainder >= (uint)Vector256<T>.Count)
                 {
                     Vectorized256(ref xRef, ref dRef, remainder);
                 }
@@ -2960,9 +3012,9 @@ private static void InvokeSpanIntoSpan<TUnaryOperator>(
                 return;
             }
 
-            if (Vector128.IsHardwareAccelerated)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && TUnaryOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector128<float>.Count))
+                if (remainder >= (uint)Vector128<T>.Count)
                 {
                     Vectorized128(ref xRef, ref dRef, remainder);
                 }
@@ -2984,7 +3036,7 @@ private static void InvokeSpanIntoSpan<TUnaryOperator>(
             SoftwareFallback(ref xRef, ref dRef, remainder);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void SoftwareFallback(ref float xRef, ref float dRef, nuint length)
+            static void SoftwareFallback(ref T xRef, ref T dRef, nuint length)
             {
                 for (nuint i = 0; i < length; i++)
                 {
@@ -2992,31 +3044,31 @@ static void SoftwareFallback(ref float xRef, ref float dRef, nuint length)
                 }
             }
 
-            static void Vectorized128(ref float xRef, ref float dRef, nuint remainder)
+            static void Vectorized128(ref T xRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector128<float> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
-                Vector128<float> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)));
+                Vector128<T> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                Vector128<T> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count));
 
-                if (remainder > (uint)(Vector128<float>.Count * 8))
+                if (remainder > (uint)(Vector128<T>.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 (float* px = &xRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -3026,96 +3078,96 @@ static void Vectorized128(ref float xRef, ref float dRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector128<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector128<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector128<T>) - ((nuint)dPtr % (uint)sizeof(Vector128<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector128<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector128<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector128<float> vector1;
-                        Vector128<float> vector2;
-                        Vector128<float> vector3;
-                        Vector128<float> vector4;
+                        Vector128<T> vector1;
+                        Vector128<T> vector2;
+                        Vector128<T> vector3;
+                        Vector128<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)));
+                                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.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)));
+                                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.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector128<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)));
+                                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.Store(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)));
+                                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.Store(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
 
@@ -3134,63 +3186,63 @@ static void Vectorized128(ref float xRef, ref float dRef, nuint remainder)
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector128<float>.Count - 1)) & (nuint)(-Vector128<float>.Count);
+                remainder = (remainder + (uint)(Vector128<T>.Count - 1)) & (nuint)(-Vector128<T>.Count);
 
-                switch (remainder / (uint)(Vector128<float>.Count))
+                switch (remainder / (uint)Vector128<T>.Count)
                 {
                     case 8:
                     {
-                        Vector128<float> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector128<float> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector128<float> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector128<float> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector128<float> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector128<float> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector128<float> vector = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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));
                         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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector128<T>.Count);
                         goto case 0;
                     }
 
@@ -3204,7 +3256,7 @@ static void Vectorized128(ref float xRef, ref float dRef, nuint remainder)
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized128Small(ref float xRef, ref float dRef, nuint remainder)
+            static void Vectorized128Small(ref T xRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -3233,31 +3285,31 @@ static void Vectorized128Small(ref float xRef, ref float dRef, nuint remainder)
                 }
             }
 
-            static void Vectorized256(ref float xRef, ref float dRef, nuint remainder)
+            static void Vectorized256(ref T xRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector256<float> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
-                Vector256<float> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)));
+                Vector256<T> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
+                Vector256<T> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count));
 
-                if (remainder > (uint)(Vector256<float>.Count * 8))
+                if (remainder > (uint)(Vector256<T>.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 (float* px = &xRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -3267,96 +3319,96 @@ static void Vectorized256(ref float xRef, ref float dRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector256<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector256<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector256<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector256<float> vector1;
-                        Vector256<float> vector2;
-                        Vector256<float> vector3;
-                        Vector256<float> vector4;
+                        Vector256<T> vector1;
+                        Vector256<T> vector2;
+                        Vector256<T> vector3;
+                        Vector256<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)));
+                                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.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)));
+                                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.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector256<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)));
+                                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.Store(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)));
+                                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.Store(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
 
@@ -3375,63 +3427,63 @@ static void Vectorized256(ref float xRef, ref float dRef, nuint remainder)
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector256<float>.Count - 1)) & (nuint)(-Vector256<float>.Count);
+                remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count);
 
-                switch (remainder / (uint)(Vector256<float>.Count))
+                switch (remainder / (uint)Vector256<T>.Count)
                 {
                     case 8:
                     {
-                        Vector256<float> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector256<float> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector256<float> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector256<float> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector256<float> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector256<float> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector256<float> vector = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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));
                         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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count);
                         goto case 0;
                     }
 
@@ -3445,7 +3497,7 @@ static void Vectorized256(ref float xRef, ref float dRef, nuint remainder)
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized256Small(ref float xRef, ref float dRef, nuint remainder)
+            static void Vectorized256Small(ref T xRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -3455,11 +3507,11 @@ static void Vectorized256Small(ref float xRef, ref float dRef, nuint remainder)
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
-                        Vector128<float> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)));
+                        Vector128<T> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<T> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -3468,7 +3520,7 @@ static void Vectorized256Small(ref float xRef, ref float dRef, nuint remainder)
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<T> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -3499,31 +3551,31 @@ static void Vectorized256Small(ref float xRef, ref float dRef, nuint remainder)
                 }
             }
 
-            static void Vectorized512(ref float xRef, ref float dRef, nuint remainder)
+            static void Vectorized512(ref T xRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector512<float> beg = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef));
-                Vector512<float> end = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count)));
+                Vector512<T> beg = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef));
+                Vector512<T> end = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count));
 
-                if (remainder > (uint)(Vector512<float>.Count * 8))
+                if (remainder > (uint)(Vector512<T>.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 (float* px = &xRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -3533,96 +3585,96 @@ static void Vectorized512(ref float xRef, ref float dRef, nuint remainder)
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector512<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector512<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector512<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector512<float> vector1;
-                        Vector512<float> vector2;
-                        Vector512<float> vector3;
-                        Vector512<float> vector4;
+                        Vector512<T> vector1;
+                        Vector512<T> vector2;
+                        Vector512<T> vector3;
+                        Vector512<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)));
+                                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.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)));
+                                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.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector512<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)));
-                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)));
-                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)));
-                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)));
+                                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.Store(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)));
-                                vector2 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)));
-                                vector3 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)));
-                                vector4 = TUnaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)));
+                                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.Store(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
 
@@ -3641,63 +3693,63 @@ static void Vectorized512(ref float xRef, ref float dRef, nuint remainder)
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector512<float>.Count - 1)) & (nuint)(-Vector512<float>.Count);
+                remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count);
 
-                switch (remainder / (uint)(Vector512<float>.Count))
+                switch (remainder / (uint)Vector512<T>.Count)
                 {
                     case 8:
                     {
-                        Vector512<float> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 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));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector512<float> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 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));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector512<float> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 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));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector512<float> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 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));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector512<float> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 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));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector512<float> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 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));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector512<float> vector = TUnaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 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));
                         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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count);
                         goto case 0;
                     }
 
@@ -3711,7 +3763,7 @@ static void Vectorized512(ref float xRef, ref float dRef, nuint remainder)
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized512Small(ref float xRef, ref float dRef, nuint remainder)
+            static void Vectorized512Small(ref T xRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -3725,11 +3777,11 @@ static void Vectorized512Small(ref float xRef, ref float dRef, nuint remainder)
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
-                        Vector256<float> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)));
+                        Vector256<T> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
+                        Vector256<T> end = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
 
                         break;
                     }
@@ -3738,7 +3790,7 @@ static void Vectorized512Small(ref float xRef, ref float dRef, nuint remainder)
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
+                        Vector256<T> beg = TUnaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -3750,11 +3802,11 @@ static void Vectorized512Small(ref float xRef, ref float dRef, nuint remainder)
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
-                        Vector128<float> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)));
+                        Vector128<T> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<T> end = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -3763,7 +3815,7 @@ static void Vectorized512Small(ref float xRef, ref float dRef, nuint remainder)
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
+                        Vector128<T> beg = TUnaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -3799,12 +3851,13 @@ static void Vectorized512Small(ref float xRef, ref float dRef, nuint remainder)
         /// Performs an element-wise operation on <paramref name="x"/> and <paramref name="y"/>,
         /// and writes the results to <paramref name="destination"/>.
         /// </summary>
-        /// <typeparam name="TBinaryOperator">
+        /// <typeparam name="T">The element type.</typeparam>
+        /// <typeparam name="TBinaryOperator{T}">
         /// Specifies the operation to perform on the pair-wise elements loaded from <paramref name="x"/> and <paramref name="y"/>.
         /// </typeparam>
-        private static void InvokeSpanSpanIntoSpan<TBinaryOperator>(
-            ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination)
-            where TBinaryOperator : struct, IBinaryOperator
+        private static void InvokeSpanSpanIntoSpan<T, TBinaryOperator>(
+            ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            where TBinaryOperator : struct, IBinaryOperator<T>
         {
             if (x.Length != y.Length)
             {
@@ -3824,15 +3877,15 @@ private static void InvokeSpanSpanIntoSpan<TBinaryOperator>(
             // in a way that allows us to have the minimum possible
             // for small sizes
 
-            ref float xRef = ref MemoryMarshal.GetReference(x);
-            ref float yRef = ref MemoryMarshal.GetReference(y);
-            ref float dRef = ref MemoryMarshal.GetReference(destination);
+            ref T xRef = ref MemoryMarshal.GetReference(x);
+            ref T yRef = ref MemoryMarshal.GetReference(y);
+            ref T dRef = ref MemoryMarshal.GetReference(destination);
 
-            nuint remainder = (uint)(x.Length);
+            nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector512<float>.Count))
+                if (remainder >= (uint)Vector512<T>.Count)
                 {
                     Vectorized512(ref xRef, ref yRef, ref dRef, remainder);
                 }
@@ -3848,9 +3901,9 @@ private static void InvokeSpanSpanIntoSpan<TBinaryOperator>(
                 return;
             }
 
-            if (Vector256.IsHardwareAccelerated)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector256<float>.Count))
+                if (remainder >= (uint)Vector256<T>.Count)
                 {
                     Vectorized256(ref xRef, ref yRef, ref dRef, remainder);
                 }
@@ -3866,9 +3919,9 @@ private static void InvokeSpanSpanIntoSpan<TBinaryOperator>(
                 return;
             }
 
-            if (Vector128.IsHardwareAccelerated)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector128<float>.Count))
+                if (remainder >= (uint)Vector128<T>.Count)
                 {
                     Vectorized128(ref xRef, ref yRef, ref dRef, remainder);
                 }
@@ -3890,7 +3943,7 @@ private static void InvokeSpanSpanIntoSpan<TBinaryOperator>(
             SoftwareFallback(ref xRef, ref yRef, ref dRef, remainder);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void SoftwareFallback(ref float xRef, ref float yRef, ref float dRef, nuint length)
+            static void SoftwareFallback(ref T xRef, ref T yRef, ref T dRef, nuint length)
             {
                 for (nuint i = 0; i < length; i++)
                 {
@@ -3899,35 +3952,35 @@ static void SoftwareFallback(ref float xRef, ref float yRef, ref float dRef, nui
                 }
             }
 
-            static void Vectorized128(ref float xRef, ref float yRef, ref float dRef, nuint remainder)
+            static void Vectorized128(ref T xRef, ref T yRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector128<float> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                              Vector128.LoadUnsafe(ref yRef));
-                Vector128<float> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                              Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)));
+                Vector128<T> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                          Vector128.LoadUnsafe(ref yRef));
+                Vector128<T> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
+                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count));
 
-                if (remainder > (uint)(Vector128<float>.Count * 8))
+                if (remainder > (uint)(Vector128<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* yPtr = py;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -3937,115 +3990,115 @@ static void Vectorized128(ref float xRef, ref float yRef, ref float dRef, nuint
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector128<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector128<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector128<T>) - ((nuint)dPtr % (uint)sizeof(Vector128<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector128<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector128<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector128<float> vector1;
-                        Vector128<float> vector2;
-                        Vector128<float> vector3;
-                        Vector128<float> vector4;
+                        Vector128<T> vector1;
+                        Vector128<T> vector2;
+                        Vector128<T> vector3;
+                        Vector128<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 0)));
-                                vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 1)));
-                                vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 2)));
-                                vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 3)));
+                                vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 0)));
+                                vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 1)));
+                                vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 2)));
+                                vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 3)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 4)));
-                                vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 5)));
-                                vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 6)));
-                                vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 7)));
+                                vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 4)));
+                                vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 5)));
+                                vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 6)));
+                                vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 7)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                yPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                yPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector128<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 0)));
-                                vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 1)));
-                                vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 2)));
-                                vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 3)));
+                                vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 0)));
+                                vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 1)));
+                                vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 2)));
+                                vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 3)));
 
-                                vector1.Store(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 4)));
-                                vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 5)));
-                                vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 6)));
-                                vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)),
-                                                                 Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 7)));
+                                vector1 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 4)));
+                                vector2 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 5)));
+                                vector3 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 6)));
+                                vector4 = TBinaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)),
+                                                                 Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 7)));
 
-                                vector1.Store(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                yPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                yPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
 
@@ -4065,70 +4118,70 @@ static void Vectorized128(ref float xRef, ref float yRef, ref float dRef, nuint
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector128<float>.Count - 1)) & (nuint)(-Vector128<float>.Count);
+                remainder = (remainder + (uint)(Vector128<T>.Count - 1)) & (nuint)(-Vector128<T>.Count);
 
-                switch (remainder / (uint)(Vector128<float>.Count))
+                switch (remainder / (uint)Vector128<T>.Count)
                 {
                     case 8:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 8)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 8));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 8)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 7)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 7));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 7)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 6)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 6));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 6)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 5)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 5));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 5)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 4)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 4));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 4)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 3)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 3));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 3)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 3)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 2)),
-                                                                         Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 2));
+                        Vector128<T> vector = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 2)),
+                                                                     Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<T>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector128<T>.Count);
                         goto case 0;
                     }
 
@@ -4142,7 +4195,7 @@ static void Vectorized128(ref float xRef, ref float yRef, ref float dRef, nuint
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized128Small(ref float xRef, ref float yRef, ref float dRef, nuint remainder)
+            static void Vectorized128Small(ref T xRef, ref T yRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -4173,35 +4226,35 @@ static void Vectorized128Small(ref float xRef, ref float yRef, ref float dRef, n
                 }
             }
 
-            static void Vectorized256(ref float xRef, ref float yRef, ref float dRef, nuint remainder)
+            static void Vectorized256(ref T xRef, ref T yRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector256<float> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                              Vector256.LoadUnsafe(ref yRef));
-                Vector256<float> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)),
-                                                              Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count)));
+                Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                                                          Vector256.LoadUnsafe(ref yRef));
+                Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
+                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count));
 
-                if (remainder > (uint)(Vector256<float>.Count * 8))
+                if (remainder > (uint)(Vector256<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* yPtr = py;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -4211,115 +4264,115 @@ static void Vectorized256(ref float xRef, ref float yRef, ref float dRef, nuint
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector256<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector256<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector256<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector256<float> vector1;
-                        Vector256<float> vector2;
-                        Vector256<float> vector3;
-                        Vector256<float> vector4;
+                        Vector256<T> vector1;
+                        Vector256<T> vector2;
+                        Vector256<T> vector3;
+                        Vector256<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 0)));
-                                vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 1)));
-                                vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 2)));
-                                vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 3)));
+                                vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)));
+                                vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)));
+                                vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)));
+                                vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 4)));
-                                vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 5)));
-                                vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 6)));
-                                vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 7)));
+                                vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)));
+                                vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)));
+                                vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)));
+                                vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                yPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                yPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector256<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 0)));
-                                vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 1)));
-                                vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 2)));
-                                vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 3)));
+                                vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)));
+                                vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)));
+                                vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)));
+                                vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)));
 
-                                vector1.Store(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 4)));
-                                vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 5)));
-                                vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 6)));
-                                vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)),
-                                                                 Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 7)));
+                                vector1 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)));
+                                vector2 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)));
+                                vector3 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)));
+                                vector4 = TBinaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)),
+                                                                 Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)));
 
-                                vector1.Store(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                yPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                yPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
 
@@ -4339,70 +4392,70 @@ static void Vectorized256(ref float xRef, ref float yRef, ref float dRef, nuint
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector256<float>.Count - 1)) & (nuint)(-Vector256<float>.Count);
+                remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count);
 
-                switch (remainder / (uint)(Vector256<float>.Count))
+                switch (remainder / (uint)Vector256<T>.Count)
                 {
                     case 8:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 8)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 8));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 7)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 7));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 6)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 6));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 5)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 5));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 4)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 4));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 3)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 3));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 3)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 2)),
-                                                                         Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 2));
+                        Vector256<T> vector = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)),
+                                                                     Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<T>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count);
                         goto case 0;
                     }
 
@@ -4416,7 +4469,7 @@ static void Vectorized256(ref float xRef, ref float yRef, ref float dRef, nuint
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized256Small(ref float xRef, ref float yRef, ref float dRef, nuint remainder)
+            static void Vectorized256Small(ref T xRef, ref T yRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -4426,13 +4479,13 @@ static void Vectorized256Small(ref float xRef, ref float yRef, ref float dRef, n
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                      Vector128.LoadUnsafe(ref yRef));
-                        Vector128<float> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                                      Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)));
+                        Vector128<T> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                  Vector128.LoadUnsafe(ref yRef));
+                        Vector128<T> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
+                                                                  Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -4441,8 +4494,8 @@ static void Vectorized256Small(ref float xRef, ref float yRef, ref float dRef, n
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                      Vector128.LoadUnsafe(ref yRef));
+                        Vector128<T> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                  Vector128.LoadUnsafe(ref yRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -4475,35 +4528,35 @@ static void Vectorized256Small(ref float xRef, ref float yRef, ref float dRef, n
                 }
             }
 
-            static void Vectorized512(ref float xRef, ref float yRef, ref float dRef, nuint remainder)
+            static void Vectorized512(ref T xRef, ref T yRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector512<float> beg = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef),
-                                                              Vector512.LoadUnsafe(ref yRef));
-                Vector512<float> end = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count)),
-                                                              Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count)));
+                Vector512<T> beg = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef),
+                                                          Vector512.LoadUnsafe(ref yRef));
+                Vector512<T> end = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count),
+                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count));
 
-                if (remainder > (uint)(Vector512<float>.Count * 8))
+                if (remainder > (uint)(Vector512<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* yPtr = py;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -4513,115 +4566,115 @@ static void Vectorized512(ref float xRef, ref float yRef, ref float dRef, nuint
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector512<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector512<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector512<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector512<float> vector1;
-                        Vector512<float> vector2;
-                        Vector512<float> vector3;
-                        Vector512<float> vector4;
+                        Vector512<T> vector1;
+                        Vector512<T> vector2;
+                        Vector512<T> vector3;
+                        Vector512<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 0)));
-                                vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 1)));
-                                vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 2)));
-                                vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 3)));
+                                vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)));
+                                vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)));
+                                vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)));
+                                vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 4)));
-                                vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 5)));
-                                vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 6)));
-                                vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 7)));
+                                vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)));
+                                vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)));
+                                vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)));
+                                vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                yPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                yPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector512<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 0)));
-                                vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 1)));
-                                vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 2)));
-                                vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 3)));
+                                vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)));
+                                vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)));
+                                vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)));
+                                vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)));
 
-                                vector1.Store(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 4)));
-                                vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 5)));
-                                vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 6)));
-                                vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)),
-                                                                 Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 7)));
+                                vector1 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)));
+                                vector2 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)));
+                                vector3 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)));
+                                vector4 = TBinaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)),
+                                                                 Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)));
 
-                                vector1.Store(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                yPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                yPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
 
@@ -4641,70 +4694,70 @@ static void Vectorized512(ref float xRef, ref float yRef, ref float dRef, nuint
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector512<float>.Count - 1)) & (nuint)(-Vector512<float>.Count);
+                remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count);
 
-                switch (remainder / (uint)(Vector512<float>.Count))
+                switch (remainder / (uint)Vector512<T>.Count)
                 {
                     case 8:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 8)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 8));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 7)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 7));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 6)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 6));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 5)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 5));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 4)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 4));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 3)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 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)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 2)),
-                                                                         Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 2));
+                        Vector512<T> vector = TBinaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)),
+                                                                     Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count);
                         goto case 0;
                     }
 
@@ -4718,7 +4771,7 @@ static void Vectorized512(ref float xRef, ref float yRef, ref float dRef, nuint
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized512Small(ref float xRef, ref float yRef, ref float dRef, nuint remainder)
+            static void Vectorized512Small(ref T xRef, ref T yRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -4732,13 +4785,13 @@ static void Vectorized512Small(ref float xRef, ref float yRef, ref float dRef, n
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                      Vector256.LoadUnsafe(ref yRef));
-                        Vector256<float> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)),
-                                                                      Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count)));
+                        Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                                                                  Vector256.LoadUnsafe(ref yRef));
+                        Vector256<T> end = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
+                                                                  Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
 
                         break;
                     }
@@ -4747,8 +4800,8 @@ static void Vectorized512Small(ref float xRef, ref float yRef, ref float dRef, n
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                      Vector256.LoadUnsafe(ref yRef));
+                        Vector256<T> beg = TBinaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                                                                  Vector256.LoadUnsafe(ref yRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -4760,13 +4813,13 @@ static void Vectorized512Small(ref float xRef, ref float yRef, ref float dRef, n
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                      Vector128.LoadUnsafe(ref yRef));
-                        Vector128<float> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                                      Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)));
+                        Vector128<T> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                  Vector128.LoadUnsafe(ref yRef));
+                        Vector128<T> end = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
+                                                                  Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -4775,8 +4828,8 @@ static void Vectorized512Small(ref float xRef, ref float yRef, ref float dRef, n
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                      Vector128.LoadUnsafe(ref yRef));
+                        Vector128<T> beg = TBinaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                  Vector128.LoadUnsafe(ref yRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -4814,18 +4867,20 @@ static void Vectorized512Small(ref float xRef, ref float yRef, ref float dRef, n
         /// Performs an element-wise operation on <paramref name="x"/> and <paramref name="y"/>,
         /// and writes the results to <paramref name="destination"/>.
         /// </summary>
+        /// <typeparam name="T">The element type.</typeparam>
         /// <typeparam name="TBinaryOperator">
         /// Specifies the operation to perform on each element loaded from <paramref name="x"/> with <paramref name="y"/>.
         /// </typeparam>
-        private static void InvokeSpanScalarIntoSpan<TBinaryOperator>(
-            ReadOnlySpan<float> x, float y, Span<float> destination)
-            where TBinaryOperator : struct, IBinaryOperator =>
-            InvokeSpanScalarIntoSpan<IdentityOperator, TBinaryOperator>(x, y, destination);
+        private static void InvokeSpanScalarIntoSpan<T, TBinaryOperator>(
+            ReadOnlySpan<T> x, T y, Span<T> destination)
+            where TBinaryOperator : struct, IBinaryOperator<T> =>
+            InvokeSpanScalarIntoSpan<T, IdentityOperator<T>, TBinaryOperator>(x, y, destination);
 
         /// <summary>
         /// Performs an element-wise operation on <paramref name="x"/> and <paramref name="y"/>,
         /// and writes the results to <paramref name="destination"/>.
         /// </summary>
+        /// <typeparam name="T">The element type.</typeparam>
         /// <typeparam name="TTransformOperator">
         /// Specifies the operation to perform on each element loaded from <paramref name="x"/>.
         /// It is not used with <paramref name="y"/>.
@@ -4833,10 +4888,10 @@ private static void InvokeSpanScalarIntoSpan<TBinaryOperator>(
         /// <typeparam name="TBinaryOperator">
         /// Specifies the operation to perform on the transformed value from <paramref name="x"/> with <paramref name="y"/>.
         /// </typeparam>
-        private static void InvokeSpanScalarIntoSpan<TTransformOperator, TBinaryOperator>(
-            ReadOnlySpan<float> x, float y, Span<float> destination)
-            where TTransformOperator : struct, IUnaryOperator
-            where TBinaryOperator : struct, IBinaryOperator
+        private static void InvokeSpanScalarIntoSpan<T, TTransformOperator, TBinaryOperator>(
+            ReadOnlySpan<T> x, T y, Span<T> destination)
+            where TTransformOperator : struct, IUnaryOperator<T>
+            where TBinaryOperator : struct, IBinaryOperator<T>
         {
             if (x.Length > destination.Length)
             {
@@ -4850,14 +4905,14 @@ private static void InvokeSpanScalarIntoSpan<TTransformOperator, TBinaryOperator
             // in a way that allows us to have the minimum possible
             // for small sizes
 
-            ref float xRef = ref MemoryMarshal.GetReference(x);
-            ref float dRef = ref MemoryMarshal.GetReference(destination);
+            ref T xRef = ref MemoryMarshal.GetReference(x);
+            ref T dRef = ref MemoryMarshal.GetReference(destination);
 
-            nuint remainder = (uint)(x.Length);
+            nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && TTransformOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector512<float>.Count))
+                if (remainder >= (uint)Vector512<T>.Count)
                 {
                     Vectorized512(ref xRef, y, ref dRef, remainder);
                 }
@@ -4873,9 +4928,9 @@ private static void InvokeSpanScalarIntoSpan<TTransformOperator, TBinaryOperator
                 return;
             }
 
-            if (Vector256.IsHardwareAccelerated)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && TTransformOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector256<float>.Count))
+                if (remainder >= (uint)Vector256<T>.Count)
                 {
                     Vectorized256(ref xRef, y, ref dRef, remainder);
                 }
@@ -4891,9 +4946,9 @@ private static void InvokeSpanScalarIntoSpan<TTransformOperator, TBinaryOperator
                 return;
             }
 
-            if (Vector128.IsHardwareAccelerated)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && TTransformOperator.Vectorizable && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector128<float>.Count))
+                if (remainder >= (uint)Vector128<T>.Count)
                 {
                     Vectorized128(ref xRef, y, ref dRef, remainder);
                 }
@@ -4915,7 +4970,7 @@ private static void InvokeSpanScalarIntoSpan<TTransformOperator, TBinaryOperator
             SoftwareFallback(ref xRef, y, ref dRef, remainder);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void SoftwareFallback(ref float xRef, float y, ref float dRef, nuint length)
+            static void SoftwareFallback(ref T xRef, T y, ref T dRef, nuint length)
             {
                 for (nuint i = 0; i < length; i++)
                 {
@@ -4924,35 +4979,35 @@ static void SoftwareFallback(ref float xRef, float y, ref float dRef, nuint leng
                 }
             }
 
-            static void Vectorized128(ref float xRef, float y, ref float dRef, nuint remainder)
+            static void Vectorized128(ref T xRef, T y, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector128<float> yVec = Vector128.Create(y);
+                Vector128<T> yVec = Vector128.Create(y);
 
-                Vector128<float> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef)),
-                                                              yVec);
-                Vector128<float> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count))),
-                                                              yVec);
+                Vector128<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef)),
+                                                          yVec);
+                Vector128<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count)),
+                                                          yVec);
 
-                if (remainder > (uint)(Vector128<float>.Count * 8))
+                if (remainder > (uint)(Vector128<T>.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 (float* px = &xRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -4962,112 +5017,112 @@ static void Vectorized128(ref float xRef, float y, ref float dRef, nuint remaind
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector128<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector128<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector128<T>) - ((nuint)dPtr % (uint)sizeof(Vector128<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector128<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector128<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector128<float> vector1;
-                        Vector128<float> vector2;
-                        Vector128<float> vector3;
-                        Vector128<float> vector4;
+                        Vector128<T> vector1;
+                        Vector128<T> vector2;
+                        Vector128<T> vector3;
+                        Vector128<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3))),
                                                                  yVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7))),
                                                                  yVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector128<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3))),
                                                                  yVec);
 
-                                vector1.Store(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7))),
                                                                  yVec);
 
-                                vector1.Store(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
 
@@ -5086,70 +5141,70 @@ static void Vectorized128(ref float xRef, float y, ref float dRef, nuint remaind
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector128<float>.Count - 1)) & (nuint)(-Vector128<float>.Count);
+                remainder = (remainder + (uint)(Vector128<T>.Count - 1)) & (nuint)(-Vector128<T>.Count);
 
-                switch (remainder / (uint)(Vector128<float>.Count))
+                switch (remainder / (uint)Vector128<T>.Count)
                 {
                     case 8:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 8))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 8));
+                        Vector128<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 8))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 7))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 7));
+                        Vector128<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 7))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 6))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 6));
+                        Vector128<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 6))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 5))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 5));
+                        Vector128<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 5))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 4))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 4));
+                        Vector128<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 4))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 3))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 3));
+                        Vector128<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 3))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector128<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 2))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 2));
+                        Vector128<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 2))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector128<T>.Count);
                         goto case 0;
                     }
 
@@ -5163,7 +5218,7 @@ static void Vectorized128(ref float xRef, float y, ref float dRef, nuint remaind
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized128Small(ref float xRef, float y, ref float dRef, nuint remainder)
+            static void Vectorized128Small(ref T xRef, T y, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -5194,35 +5249,35 @@ static void Vectorized128Small(ref float xRef, float y, ref float dRef, nuint re
                 }
             }
 
-            static void Vectorized256(ref float xRef, float y, ref float dRef, nuint remainder)
+            static void Vectorized256(ref T xRef, T y, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector256<float> yVec = Vector256.Create(y);
+                Vector256<T> yVec = Vector256.Create(y);
 
-                Vector256<float> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)),
-                                                              yVec);
-                Vector256<float> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count))),
-                                                              yVec);
+                Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)),
+                                                          yVec);
+                Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)),
+                                                          yVec);
 
-                if (remainder > (uint)(Vector256<float>.Count * 8))
+                if (remainder > (uint)(Vector256<T>.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 (float* px = &xRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -5232,112 +5287,112 @@ static void Vectorized256(ref float xRef, float y, ref float dRef, nuint remaind
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector256<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector256<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector256<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector256<float> vector1;
-                        Vector256<float> vector2;
-                        Vector256<float> vector3;
-                        Vector256<float> vector4;
+                        Vector256<T> vector1;
+                        Vector256<T> vector2;
+                        Vector256<T> vector3;
+                        Vector256<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))),
                                                                  yVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))),
                                                                  yVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector256<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3))),
                                                                  yVec);
 
-                                vector1.Store(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7))),
                                                                  yVec);
 
-                                vector1.Store(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
 
@@ -5356,70 +5411,70 @@ static void Vectorized256(ref float xRef, float y, ref float dRef, nuint remaind
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector256<float>.Count - 1)) & (nuint)(-Vector256<float>.Count);
+                remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count);
 
-                switch (remainder / (uint)(Vector256<float>.Count))
+                switch (remainder / (uint)Vector256<T>.Count)
                 {
                     case 8:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 8))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 8));
+                        Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 7))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 7));
+                        Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 6))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 6));
+                        Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 5))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 5));
+                        Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 4))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 4));
+                        Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 3))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 3));
+                        Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector256<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 2))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 2));
+                        Vector256<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count);
                         goto case 0;
                     }
 
@@ -5433,7 +5488,7 @@ static void Vectorized256(ref float xRef, float y, ref float dRef, nuint remaind
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized256Small(ref float xRef, float y, ref float dRef, nuint remainder)
+            static void Vectorized256Small(ref T xRef, T y, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -5443,15 +5498,15 @@ static void Vectorized256Small(ref float xRef, float y, ref float dRef, nuint re
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> yVec = Vector128.Create(y);
+                        Vector128<T> yVec = Vector128.Create(y);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef)),
-                                                                                                yVec);
-                        Vector128<float> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count))),
-                                                                                                yVec);
+                        Vector128<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef)),
+                                                                                            yVec);
+                        Vector128<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count)),
+                                                                                            yVec);
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -5460,8 +5515,8 @@ static void Vectorized256Small(ref float xRef, float y, ref float dRef, nuint re
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef)),
-                                                                                                Vector128.Create(y));
+                        Vector128<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef)),
+                                                                                            Vector128.Create(y));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -5494,35 +5549,35 @@ static void Vectorized256Small(ref float xRef, float y, ref float dRef, nuint re
                 }
             }
 
-            static void Vectorized512(ref float xRef, float y, ref float dRef, nuint remainder)
+            static void Vectorized512(ref T xRef, T y, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector512<float> yVec = Vector512.Create(y);
+                Vector512<T> yVec = Vector512.Create(y);
 
-                Vector512<float> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef)),
-                                                              yVec);
-                Vector512<float> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count))),
-                                                              yVec);
+                Vector512<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef)),
+                                                          yVec);
+                Vector512<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count)),
+                                                          yVec);
 
-                if (remainder > (uint)(Vector512<float>.Count * 8))
+                if (remainder > (uint)(Vector512<T>.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 (float* px = &xRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -5532,112 +5587,112 @@ static void Vectorized512(ref float xRef, float y, ref float dRef, nuint remaind
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector512<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector512<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector512<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector512<float> vector1;
-                        Vector512<float> vector2;
-                        Vector512<float> vector3;
-                        Vector512<float> vector4;
+                        Vector512<T> vector1;
+                        Vector512<T> vector2;
+                        Vector512<T> vector3;
+                        Vector512<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3))),
                                                                  yVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7))),
                                                                  yVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector512<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3))),
                                                                  yVec);
 
-                                vector1.Store(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4))),
+                                vector1 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4))),
                                                                  yVec);
-                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5))),
+                                vector2 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5))),
                                                                  yVec);
-                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6))),
+                                vector3 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6))),
                                                                  yVec);
-                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7))),
+                                vector4 = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7))),
                                                                  yVec);
 
-                                vector1.Store(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
 
@@ -5656,70 +5711,70 @@ static void Vectorized512(ref float xRef, float y, ref float dRef, nuint remaind
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector512<float>.Count - 1)) & (nuint)(-Vector512<float>.Count);
+                remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count);
 
-                switch (remainder / (uint)(Vector512<float>.Count))
+                switch (remainder / (uint)Vector512<T>.Count)
                 {
                     case 8:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 8))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 8));
+                        Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 7))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 7));
+                        Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 6))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 6));
+                        Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 5))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 5));
+                        Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 4))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 4));
+                        Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 3))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 3));
+                        Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector512<float> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 2))),
-                                                                         yVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 2));
+                        Vector512<T> vector = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2))),
+                                                                     yVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count);
                         goto case 0;
                     }
 
@@ -5733,7 +5788,7 @@ static void Vectorized512(ref float xRef, float y, ref float dRef, nuint remaind
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized512Small(ref float xRef, float y, ref float dRef, nuint remainder)
+            static void Vectorized512Small(ref T xRef, T y, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -5747,15 +5802,15 @@ static void Vectorized512Small(ref float xRef, float y, ref float dRef, nuint re
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> yVec = Vector256.Create(y);
+                        Vector256<T> yVec = Vector256.Create(y);
 
-                        Vector256<float> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)),
-                                                                      yVec);
-                        Vector256<float> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count))),
-                                                                      yVec);
+                        Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)),
+                                                                  yVec);
+                        Vector256<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count)),
+                                                                  yVec);
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
 
                         break;
                     }
@@ -5764,8 +5819,8 @@ static void Vectorized512Small(ref float xRef, float y, ref float dRef, nuint re
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)),
-                                                                      Vector256.Create(y));
+                        Vector256<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector256.LoadUnsafe(ref xRef)),
+                                                                  Vector256.Create(y));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -5777,15 +5832,15 @@ static void Vectorized512Small(ref float xRef, float y, ref float dRef, nuint re
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> yVec = Vector128.Create(y);
+                        Vector128<T> yVec = Vector128.Create(y);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef)),
-                                                                                                yVec);
-                        Vector128<float> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count))),
-                                                                                                yVec);
+                        Vector128<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef)),
+                                                                                            yVec);
+                        Vector128<T> end = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count)),
+                                                                                            yVec);
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -5794,8 +5849,8 @@ static void Vectorized512Small(ref float xRef, float y, ref float dRef, nuint re
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef)),
-                                                                                                Vector128.Create(y));
+                        Vector128<T> beg = TBinaryOperator.Invoke(TTransformOperator.Invoke(Vector128.LoadUnsafe(ref xRef)),
+                                                                                            Vector128.Create(y));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -5833,13 +5888,14 @@ static void Vectorized512Small(ref float xRef, float y, ref float dRef, nuint re
         /// Performs an element-wise operation on <paramref name="x"/>, <paramref name="y"/>, and <paramref name="z"/>,
         /// and writes the results to <paramref name="destination"/>.
         /// </summary>
+        /// <typeparam name="T">The element type.</typeparam>
         /// <typeparam name="TTernaryOperator">
         /// Specifies the operation to perform on the pair-wise elements loaded from <paramref name="x"/>, <paramref name="y"/>,
         /// and <paramref name="z"/>.
         /// </typeparam>
-        private static void InvokeSpanSpanSpanIntoSpan<TTernaryOperator>(
-            ReadOnlySpan<float> x, ReadOnlySpan<float> y, ReadOnlySpan<float> z, Span<float> destination)
-            where TTernaryOperator : struct, ITernaryOperator
+        private static void InvokeSpanSpanSpanIntoSpan<T, TTernaryOperator>(
+            ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> z, Span<T> destination)
+            where TTernaryOperator : struct, ITernaryOperator<T>
         {
             if (x.Length != y.Length || x.Length != z.Length)
             {
@@ -5860,16 +5916,16 @@ private static void InvokeSpanSpanSpanIntoSpan<TTernaryOperator>(
             // in a way that allows us to have the minimum possible
             // for small sizes
 
-            ref float xRef = ref MemoryMarshal.GetReference(x);
-            ref float yRef = ref MemoryMarshal.GetReference(y);
-            ref float zRef = ref MemoryMarshal.GetReference(z);
-            ref float dRef = ref MemoryMarshal.GetReference(destination);
+            ref T xRef = ref MemoryMarshal.GetReference(x);
+            ref T yRef = ref MemoryMarshal.GetReference(y);
+            ref T zRef = ref MemoryMarshal.GetReference(z);
+            ref T dRef = ref MemoryMarshal.GetReference(destination);
 
-            nuint remainder = (uint)(x.Length);
+            nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector512<float>.Count))
+                if (remainder >= (uint)Vector512<T>.Count)
                 {
                     Vectorized512(ref xRef, ref yRef, ref zRef, ref dRef, remainder);
                 }
@@ -5885,9 +5941,9 @@ private static void InvokeSpanSpanSpanIntoSpan<TTernaryOperator>(
                 return;
             }
 
-            if (Vector256.IsHardwareAccelerated)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector256<float>.Count))
+                if (remainder >= (uint)Vector256<T>.Count)
                 {
                     Vectorized256(ref xRef, ref yRef, ref zRef, ref dRef, remainder);
                 }
@@ -5903,9 +5959,9 @@ private static void InvokeSpanSpanSpanIntoSpan<TTernaryOperator>(
                 return;
             }
 
-            if (Vector128.IsHardwareAccelerated)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector128<float>.Count))
+                if (remainder >= (uint)Vector128<T>.Count)
                 {
                     Vectorized128(ref xRef, ref yRef, ref zRef, ref dRef, remainder);
                 }
@@ -5927,7 +5983,7 @@ private static void InvokeSpanSpanSpanIntoSpan<TTernaryOperator>(
             SoftwareFallback(ref xRef, ref yRef, ref zRef, ref dRef, remainder);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void SoftwareFallback(ref float xRef, ref float yRef, ref float zRef, ref float dRef, nuint length)
+            static void SoftwareFallback(ref T xRef, ref T yRef, ref T zRef, ref T dRef, nuint length)
             {
                 for (nuint i = 0; i < length; i++)
                 {
@@ -5937,39 +5993,39 @@ static void SoftwareFallback(ref float xRef, ref float yRef, ref float zRef, ref
                 }
             }
 
-            static void Vectorized128(ref float xRef, ref float yRef, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized128(ref T xRef, ref T yRef, ref T zRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                               Vector128.LoadUnsafe(ref yRef),
-                                                               Vector128.LoadUnsafe(ref zRef));
-                Vector128<float> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                               Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)),
-                                                               Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count)));
+                Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                           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));
 
-                if (remainder > (uint)(Vector128<float>.Count * 8))
+                if (remainder > (uint)(Vector128<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
-                    fixed (float* pz = &zRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
+                    fixed (T* pz = &zRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
-                        float* zPtr = pz;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* yPtr = py;
+                        T* zPtr = pz;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -5979,134 +6035,134 @@ static void Vectorized128(ref float xRef, ref float yRef, ref float zRef, ref fl
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector128<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector128<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector128<T>) - ((nuint)dPtr % (uint)sizeof(Vector128<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
                             zPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector128<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector128<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector128<float> vector1;
-                        Vector128<float> vector2;
-                        Vector128<float> vector3;
-                        Vector128<float> vector4;
+                        Vector128<T> vector1;
+                        Vector128<T> vector2;
+                        Vector128<T> vector3;
+                        Vector128<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 0)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 1)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 2)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 3)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 3)));
-
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 3));
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 0)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 1)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 2)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 3)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 4)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 5)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 6)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 7)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 7)));
-
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 7));
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 4)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 5)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 6)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 7)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                yPtr += (uint)(Vector128<float>.Count * 8);
-                                zPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                yPtr += (uint)(Vector128<T>.Count * 8);
+                                zPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector128<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 0)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 1)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 2)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 3)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 3)));
-
-                                vector1.Store(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.Count * 3));
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 0)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 1)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 2)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 3)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 4)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 5)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 6)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 7)),
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 7)));
-
-                                vector1.Store(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.Count * 7));
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 4)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 5)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 6)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 7)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                yPtr += (uint)(Vector128<float>.Count * 8);
-                                zPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                yPtr += (uint)(Vector128<T>.Count * 8);
+                                zPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
 
@@ -6127,77 +6183,77 @@ static void Vectorized128(ref float xRef, ref float yRef, ref float zRef, ref fl
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector128<float>.Count - 1)) & (nuint)(-Vector128<float>.Count);
+                remainder = (remainder + (uint)(Vector128<T>.Count - 1)) & (nuint)(-Vector128<T>.Count);
 
-                switch (remainder / (uint)(Vector128<float>.Count))
+                switch (remainder / (uint)Vector128<T>.Count)
                 {
                     case 8:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 8)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 8)),
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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)),
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 7)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 7)),
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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)),
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 6)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 6)),
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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)),
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 5)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 5)),
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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)),
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 4)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 4)),
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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)),
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 3)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 3)),
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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)),
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 3)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 2)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 2)),
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 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)),
+                                                                      Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector128<T>.Count);
                         goto case 0;
                     }
 
@@ -6211,7 +6267,7 @@ static void Vectorized128(ref float xRef, ref float yRef, ref float zRef, ref fl
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized128Small(ref float xRef, ref float yRef, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized128Small(ref T xRef, ref T yRef, ref T zRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -6244,39 +6300,39 @@ static void Vectorized128Small(ref float xRef, ref float yRef, ref float zRef, r
                 }
             }
 
-            static void Vectorized256(ref float xRef, ref float yRef, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized256(ref T xRef, ref T yRef, ref T zRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector256<float> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                               Vector256.LoadUnsafe(ref yRef),
-                                                               Vector256.LoadUnsafe(ref zRef));
-                Vector256<float> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)),
-                                                               Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count)),
-                                                               Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count)));
+                Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                                                           Vector256.LoadUnsafe(ref yRef),
+                                                           Vector256.LoadUnsafe(ref zRef));
+                Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
+                                                           Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count),
+                                                           Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count));
 
-                if (remainder > (uint)(Vector256<float>.Count * 8))
+                if (remainder > (uint)(Vector256<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
-                    fixed (float* pz = &zRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
+                    fixed (T* pz = &zRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
-                        float* zPtr = pz;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* yPtr = py;
+                        T* zPtr = pz;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -6286,134 +6342,134 @@ static void Vectorized256(ref float xRef, ref float yRef, ref float zRef, ref fl
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector256<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector256<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (nuint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
                             zPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector256<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector256<float> vector1;
-                        Vector256<float> vector2;
-                        Vector256<float> vector3;
-                        Vector256<float> vector4;
+                        Vector256<T> vector1;
+                        Vector256<T> vector2;
+                        Vector256<T> vector3;
+                        Vector256<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 0)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 1)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 2)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 3)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 3)));
-
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 3));
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 4)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 5)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 6)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 7)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 7)));
-
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 7));
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                yPtr += (uint)(Vector256<float>.Count * 8);
-                                zPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                yPtr += (uint)(Vector256<T>.Count * 8);
+                                zPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector256<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 0)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 1)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 2)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 3)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 3)));
-
-                                vector1.Store(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.Count * 3));
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 4)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 5)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 6)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 7)),
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 7)));
-
-                                vector1.Store(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.Count * 7));
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                yPtr += (uint)(Vector256<float>.Count * 8);
-                                zPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                yPtr += (uint)(Vector256<T>.Count * 8);
+                                zPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
 
@@ -6434,77 +6490,77 @@ static void Vectorized256(ref float xRef, ref float yRef, ref float zRef, ref fl
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector256<float>.Count - 1)) & (nuint)(-Vector256<float>.Count);
+                remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count);
 
-                switch (remainder / (uint)(Vector256<float>.Count))
+                switch (remainder / (uint)Vector256<T>.Count)
                 {
                     case 8:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 8)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 8)),
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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)),
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 7)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 7)),
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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)),
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 6)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 6)),
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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)),
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 5)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 5)),
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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)),
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 4)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 4)),
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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)),
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 3)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 3)),
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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)),
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 3)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 2)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 2)),
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 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)),
+                                                                      Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count);
                         goto case 0;
                     }
 
@@ -6518,7 +6574,7 @@ static void Vectorized256(ref float xRef, ref float yRef, ref float zRef, ref fl
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized256Small(ref float xRef, ref float yRef, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized256Small(ref T xRef, ref T yRef, ref T zRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -6528,15 +6584,15 @@ static void Vectorized256Small(ref float xRef, ref float yRef, ref float zRef, r
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.LoadUnsafe(ref yRef),
-                                                                       Vector128.LoadUnsafe(ref zRef));
-                        Vector128<float> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                                       Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)),
-                                                                       Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count)));
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                   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));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -6545,9 +6601,9 @@ static void Vectorized256Small(ref float xRef, ref float yRef, ref float zRef, r
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.LoadUnsafe(ref yRef),
-                                                                       Vector128.LoadUnsafe(ref zRef));
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                   Vector128.LoadUnsafe(ref yRef),
+                                                                   Vector128.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -6582,39 +6638,39 @@ static void Vectorized256Small(ref float xRef, ref float yRef, ref float zRef, r
                 }
             }
 
-            static void Vectorized512(ref float xRef, ref float yRef, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized512(ref T xRef, ref T yRef, ref T zRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector512<float> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef),
-                                                               Vector512.LoadUnsafe(ref yRef),
-                                                               Vector512.LoadUnsafe(ref zRef));
-                Vector512<float> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count)),
-                                                               Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count)),
-                                                               Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count)));
+                Vector512<T> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef),
+                                                           Vector512.LoadUnsafe(ref yRef),
+                                                           Vector512.LoadUnsafe(ref zRef));
+                Vector512<T> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count),
+                                                           Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count),
+                                                           Vector512.LoadUnsafe(ref zRef, remainder - (uint)Vector512<T>.Count));
 
-                if (remainder > (uint)(Vector512<float>.Count * 8))
+                if (remainder > (uint)(Vector512<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
-                    fixed (float* pz = &zRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
+                    fixed (T* pz = &zRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
-                        float* zPtr = pz;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* yPtr = py;
+                        T* zPtr = pz;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -6624,134 +6680,134 @@ static void Vectorized512(ref float xRef, ref float yRef, ref float zRef, ref fl
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector512<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector512<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
                             zPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector512<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector512<float> vector1;
-                        Vector512<float> vector2;
-                        Vector512<float> vector3;
-                        Vector512<float> vector4;
+                        Vector512<T> vector1;
+                        Vector512<T> vector2;
+                        Vector512<T> vector3;
+                        Vector512<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 0)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 1)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 2)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 3)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 3)));
-
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 3));
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 4)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 5)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 6)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 7)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 7)));
-
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 7));
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                yPtr += (uint)(Vector512<float>.Count * 8);
-                                zPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                yPtr += (uint)(Vector512<T>.Count * 8);
+                                zPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector512<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 0)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 1)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 2)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 3)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 3)));
-
-                                vector1.Store(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.Count * 3));
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 4)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 5)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 6)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 7)),
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 7)));
-
-                                vector1.Store(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.Count * 7));
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                yPtr += (uint)(Vector512<float>.Count * 8);
-                                zPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                yPtr += (uint)(Vector512<T>.Count * 8);
+                                zPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
 
@@ -6772,77 +6828,77 @@ static void Vectorized512(ref float xRef, ref float yRef, ref float zRef, ref fl
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector512<float>.Count - 1)) & (nuint)(-Vector512<float>.Count);
+                remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count);
 
-                switch (remainder / (uint)(Vector512<float>.Count))
+                switch (remainder / (uint)Vector512<T>.Count)
                 {
                     case 8:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 8)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 8)),
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 8));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 8)),
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 7)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 7)),
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 7));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 7)),
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 6)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 6)),
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 6));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 6)),
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 5)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 5)),
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 5));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 5)),
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 4)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 4)),
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 4));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 4)),
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 3)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 3)),
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 3));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 3)),
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 3)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 2)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 2)),
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 2));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 2)),
+                                                                      Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count);
                         goto case 0;
                     }
 
@@ -6856,7 +6912,7 @@ static void Vectorized512(ref float xRef, ref float yRef, ref float zRef, ref fl
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized512Small(ref float xRef, ref float yRef, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized512Small(ref T xRef, ref T yRef, ref T zRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -6870,15 +6926,15 @@ static void Vectorized512Small(ref float xRef, ref float yRef, ref float zRef, r
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
-                                                                       Vector256.LoadUnsafe(ref yRef),
-                                                                       Vector256.LoadUnsafe(ref zRef));
-                        Vector256<float> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)),
-                                                                       Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count)),
-                                                                       Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count)));
+                        Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                                                                   Vector256.LoadUnsafe(ref yRef),
+                                                                   Vector256.LoadUnsafe(ref zRef));
+                        Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
+                                                                   Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count),
+                                                                   Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
 
                         break;
                     }
@@ -6887,7 +6943,7 @@ static void Vectorized512Small(ref float xRef, ref float yRef, ref float zRef, r
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                        Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
                                                                        Vector256.LoadUnsafe(ref yRef),
                                                                        Vector256.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
@@ -6901,15 +6957,15 @@ static void Vectorized512Small(ref float xRef, ref float yRef, ref float zRef, r
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
                                                                        Vector128.LoadUnsafe(ref yRef),
                                                                        Vector128.LoadUnsafe(ref zRef));
-                        Vector128<float> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                                       Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)),
-                                                                       Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count)));
+                        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));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -6918,7 +6974,7 @@ static void Vectorized512Small(ref float xRef, ref float yRef, ref float zRef, r
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
                                                                        Vector128.LoadUnsafe(ref yRef),
                                                                        Vector128.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
@@ -6960,13 +7016,14 @@ static void Vectorized512Small(ref float xRef, ref float yRef, ref float zRef, r
         /// Performs an element-wise operation on <paramref name="x"/>, <paramref name="y"/>, and <paramref name="z"/>,
         /// and writes the results to <paramref name="destination"/>.
         /// </summary>
+        /// <typeparam name="T">The element type.</typeparam>
         /// <typeparam name="TTernaryOperator">
         /// Specifies the operation to perform on the pair-wise elements loaded from <paramref name="x"/> and <paramref name="y"/>
         /// with <paramref name="z"/>.
         /// </typeparam>
-        private static void InvokeSpanSpanScalarIntoSpan<TTernaryOperator>(
-            ReadOnlySpan<float> x, ReadOnlySpan<float> y, float z, Span<float> destination)
-            where TTernaryOperator : struct, ITernaryOperator
+        private static void InvokeSpanSpanScalarIntoSpan<T, TTernaryOperator>(
+            ReadOnlySpan<T> x, ReadOnlySpan<T> y, T z, Span<T> destination)
+            where TTernaryOperator : struct, ITernaryOperator<T>
         {
             if (x.Length != y.Length)
             {
@@ -6986,15 +7043,15 @@ private static void InvokeSpanSpanScalarIntoSpan<TTernaryOperator>(
             // in a way that allows us to have the minimum possible
             // for small sizes
 
-            ref float xRef = ref MemoryMarshal.GetReference(x);
-            ref float yRef = ref MemoryMarshal.GetReference(y);
-            ref float dRef = ref MemoryMarshal.GetReference(destination);
+            ref T xRef = ref MemoryMarshal.GetReference(x);
+            ref T yRef = ref MemoryMarshal.GetReference(y);
+            ref T dRef = ref MemoryMarshal.GetReference(destination);
 
-            nuint remainder = (uint)(x.Length);
+            nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector512<float>.Count))
+                if (remainder >= (uint)Vector512<T>.Count)
                 {
                     Vectorized512(ref xRef, ref yRef, z, ref dRef, remainder);
                 }
@@ -7010,9 +7067,9 @@ private static void InvokeSpanSpanScalarIntoSpan<TTernaryOperator>(
                 return;
             }
 
-            if (Vector256.IsHardwareAccelerated)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector256<float>.Count))
+                if (remainder >= (uint)Vector256<T>.Count)
                 {
                     Vectorized256(ref xRef, ref yRef, z, ref dRef, remainder);
                 }
@@ -7028,9 +7085,9 @@ private static void InvokeSpanSpanScalarIntoSpan<TTernaryOperator>(
                 return;
             }
 
-            if (Vector128.IsHardwareAccelerated)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector128<float>.Count))
+                if (remainder >= (uint)Vector128<T>.Count)
                 {
                     Vectorized128(ref xRef, ref yRef, z, ref dRef, remainder);
                 }
@@ -7052,7 +7109,7 @@ private static void InvokeSpanSpanScalarIntoSpan<TTernaryOperator>(
             SoftwareFallback(ref xRef, ref yRef, z, ref dRef, remainder);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void SoftwareFallback(ref float xRef, ref float yRef, float z, ref float dRef, nuint length)
+            static void SoftwareFallback(ref T xRef, ref T yRef, T z, ref T dRef, nuint length)
             {
                 for (nuint i = 0; i < length; i++)
                 {
@@ -7062,39 +7119,39 @@ static void SoftwareFallback(ref float xRef, ref float yRef, float z, ref float
                 }
             }
 
-            static void Vectorized128(ref float xRef, ref float yRef, float z, ref float dRef, nuint remainder)
+            static void Vectorized128(ref T xRef, ref T yRef, T z, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector128<float> zVec = Vector128.Create(z);
+                Vector128<T> zVec = Vector128.Create(z);
 
-                Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
                                                                Vector128.LoadUnsafe(ref yRef),
                                                                zVec);
-                Vector128<float> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                               Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)),
+                Vector128<T> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
+                                                               Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count),
                                                                zVec);
 
-                if (remainder > (uint)(Vector128<float>.Count * 8))
+                if (remainder > (uint)(Vector128<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* yPtr = py;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -7104,131 +7161,131 @@ static void Vectorized128(ref float xRef, ref float yRef, float z, ref float dRe
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector128<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector128<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector128<T>) - ((nuint)dPtr % (uint)sizeof(Vector128<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector128<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector128<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector128<float> vector1;
-                        Vector128<float> vector2;
-                        Vector128<float> vector3;
-                        Vector128<float> vector4;
+                        Vector128<T> vector1;
+                        Vector128<T> vector2;
+                        Vector128<T> vector3;
+                        Vector128<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 0)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 1)),
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 1)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 2)),
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 2)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 3)),
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 3)),
                                                                   zVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 4)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 5)),
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 5)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 6)),
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 6)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 7)),
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 7)),
                                                                   zVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                yPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                yPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector128<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 0)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 1)),
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 1)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 2)),
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 2)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 3)),
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 3)),
                                                                   zVec);
 
-                                vector1.Store(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 4)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 5)),
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 5)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 6)),
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 6)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)),
-                                                                  Vector128.Load(yPtr + (uint)(Vector128<float>.Count * 7)),
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)),
+                                                                  Vector128.Load(yPtr + (uint)(Vector128<T>.Count * 7)),
                                                                   zVec);
 
-                                vector1.Store(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                yPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                yPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
 
@@ -7248,77 +7305,77 @@ static void Vectorized128(ref float xRef, ref float yRef, float z, ref float dRe
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector128<float>.Count - 1)) & (nuint)(-Vector128<float>.Count);
+                remainder = (remainder + (uint)(Vector128<T>.Count - 1)) & (nuint)(-Vector128<T>.Count);
 
-                switch (remainder / (uint)(Vector128<float>.Count))
+                switch (remainder / (uint)Vector128<T>.Count)
                 {
                     case 8:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 8)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 8));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 7)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 7));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 6)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 6));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 5)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 5));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 4)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 4));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 3)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 3));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 2)),
-                                                                          Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 2));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector128<T>.Count);
                         goto case 0;
                     }
 
@@ -7332,7 +7389,7 @@ static void Vectorized128(ref float xRef, ref float yRef, float z, ref float dRe
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized128Small(ref float xRef, ref float yRef, float z, ref float dRef, nuint remainder)
+            static void Vectorized128Small(ref T xRef, ref T yRef, T z, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -7365,39 +7422,39 @@ static void Vectorized128Small(ref float xRef, ref float yRef, float z, ref floa
                 }
             }
 
-            static void Vectorized256(ref float xRef, ref float yRef, float z, ref float dRef, nuint remainder)
+            static void Vectorized256(ref T xRef, ref T yRef, T z, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector256<float> zVec = Vector256.Create(z);
+                Vector256<T> zVec = Vector256.Create(z);
 
-                Vector256<float> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
                                                                Vector256.LoadUnsafe(ref yRef),
                                                                zVec);
-                Vector256<float> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)),
-                                                               Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count)),
+                Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
+                                                               Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count),
                                                                zVec);
 
-                if (remainder > (uint)(Vector256<float>.Count * 8))
+                if (remainder > (uint)(Vector256<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* yPtr = py;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -7407,131 +7464,131 @@ static void Vectorized256(ref float xRef, ref float yRef, float z, ref float dRe
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector256<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector256<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector256<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector256<float> vector1;
-                        Vector256<float> vector2;
-                        Vector256<float> vector3;
-                        Vector256<float> vector4;
+                        Vector256<T> vector1;
+                        Vector256<T> vector2;
+                        Vector256<T> vector3;
+                        Vector256<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 1)),
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 2)),
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 3)),
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)),
                                                                   zVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 5)),
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 6)),
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 7)),
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)),
                                                                   zVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                yPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                yPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector256<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 0)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 1)),
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 1)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 2)),
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 2)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 3)),
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 3)),
                                                                   zVec);
 
-                                vector1.Store(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 4)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 5)),
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 5)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 6)),
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 6)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)),
-                                                                  Vector256.Load(yPtr + (uint)(Vector256<float>.Count * 7)),
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)),
+                                                                  Vector256.Load(yPtr + (uint)(Vector256<T>.Count * 7)),
                                                                   zVec);
 
-                                vector1.Store(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                yPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                yPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
 
@@ -7551,77 +7608,77 @@ static void Vectorized256(ref float xRef, ref float yRef, float z, ref float dRe
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector256<float>.Count - 1)) & (nuint)(-Vector256<float>.Count);
+                remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count);
 
-                switch (remainder / (uint)(Vector256<float>.Count))
+                switch (remainder / (uint)Vector256<T>.Count)
                 {
                     case 8:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 8)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 8));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 7)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 7));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 6)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 6));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 5)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 5));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 4)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 4));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 3)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 3));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 2)),
-                                                                          Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count * 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);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 2));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count);
                         goto case 0;
                     }
 
@@ -7635,7 +7692,7 @@ static void Vectorized256(ref float xRef, ref float yRef, float z, ref float dRe
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized256Small(ref float xRef, ref float yRef, float z, ref float dRef, nuint remainder)
+            static void Vectorized256Small(ref T xRef, ref T yRef, T z, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -7645,17 +7702,17 @@ static void Vectorized256Small(ref float xRef, ref float yRef, float z, ref floa
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> zVec = Vector128.Create(z);
+                        Vector128<T> zVec = Vector128.Create(z);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.LoadUnsafe(ref yRef),
-                                                                       zVec);
-                        Vector128<float> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                                       Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)),
-                                                                       zVec);
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                   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);
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -7664,9 +7721,9 @@ static void Vectorized256Small(ref float xRef, ref float yRef, float z, ref floa
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
-                                                                       Vector128.LoadUnsafe(ref yRef),
-                                                                       Vector128.Create(z));
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                                                                   Vector128.LoadUnsafe(ref yRef),
+                                                                   Vector128.Create(z));
                         beg.StoreUnsafe(ref dRef);
 
                         break;
@@ -7701,39 +7758,39 @@ static void Vectorized256Small(ref float xRef, ref float yRef, float z, ref floa
                 }
             }
 
-            static void Vectorized512(ref float xRef, ref float yRef, float z, ref float dRef, nuint remainder)
+            static void Vectorized512(ref T xRef, ref T yRef, T z, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector512<float> zVec = Vector512.Create(z);
+                Vector512<T> zVec = Vector512.Create(z);
 
-                Vector512<float> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef),
-                                                               Vector512.LoadUnsafe(ref yRef),
-                                                               zVec);
-                Vector512<float> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count)),
-                                                               Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count)),
-                                                               zVec);
+                Vector512<T> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef),
+                                                           Vector512.LoadUnsafe(ref yRef),
+                                                           zVec);
+                Vector512<T> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count),
+                                                           Vector512.LoadUnsafe(ref yRef, remainder - (uint)Vector512<T>.Count),
+                                                           zVec);
 
-                if (remainder > (uint)(Vector512<float>.Count * 8))
+                if (remainder > (uint)(Vector512<T>.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 (float* px = &xRef)
-                    fixed (float* py = &yRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* py = &yRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* yPtr = py;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* yPtr = py;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -7743,131 +7800,131 @@ static void Vectorized512(ref float xRef, ref float yRef, float z, ref float dRe
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector512<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector512<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             yPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector512<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector512<float> vector1;
-                        Vector512<float> vector2;
-                        Vector512<float> vector3;
-                        Vector512<float> vector4;
+                        Vector512<T> vector1;
+                        Vector512<T> vector2;
+                        Vector512<T> vector3;
+                        Vector512<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 1)),
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 2)),
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 3)),
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)),
                                                                   zVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 5)),
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 6)),
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 7)),
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)),
                                                                   zVec);
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                yPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                yPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector512<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 0)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 1)),
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 1)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 2)),
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 2)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 3)),
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 3)),
                                                                   zVec);
 
-                                vector1.Store(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 4)),
                                                                   zVec);
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 5)),
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 5)),
                                                                   zVec);
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 6)),
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 6)),
                                                                   zVec);
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)),
-                                                                  Vector512.Load(yPtr + (uint)(Vector512<float>.Count * 7)),
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)),
+                                                                  Vector512.Load(yPtr + (uint)(Vector512<T>.Count * 7)),
                                                                   zVec);
 
-                                vector1.Store(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                yPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                yPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
 
@@ -7887,77 +7944,77 @@ static void Vectorized512(ref float xRef, ref float yRef, float z, ref float dRe
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector512<float>.Count - 1)) & (nuint)(-Vector512<float>.Count);
+                remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count);
 
-                switch (remainder / (uint)(Vector512<float>.Count))
+                switch (remainder / (uint)Vector512<T>.Count)
                 {
                     case 8:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 8)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 8)),
-                                                                          zVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 8));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 8)),
+                                                                      zVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 7)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 7)),
-                                                                          zVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 7));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 7)),
+                                                                      zVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 6)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 6)),
-                                                                          zVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 6));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 6)),
+                                                                      zVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 5)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 5)),
-                                                                          zVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 5));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 5)),
+                                                                      zVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 4)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 4)),
-                                                                          zVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 4));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 4)),
+                                                                      zVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 3)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 3)),
-                                                                          zVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 3));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 3)),
+                                                                      zVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 2)),
-                                                                          Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<float>.Count * 2)),
-                                                                          zVec);
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 2));
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)),
+                                                                      Vector512.LoadUnsafe(ref yRef, remainder - (uint)(Vector512<T>.Count * 2)),
+                                                                      zVec);
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count);
                         goto case 0;
                     }
 
@@ -7971,7 +8028,7 @@ static void Vectorized512(ref float xRef, ref float yRef, float z, ref float dRe
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized512Small(ref float xRef, ref float yRef, float z, ref float dRef, nuint remainder)
+            static void Vectorized512Small(ref T xRef, ref T yRef, T z, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -7985,17 +8042,17 @@ static void Vectorized512Small(ref float xRef, ref float yRef, float z, ref floa
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> zVec = Vector256.Create(z);
+                        Vector256<T> zVec = Vector256.Create(z);
 
-                        Vector256<float> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                        Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
                                                                        Vector256.LoadUnsafe(ref yRef),
                                                                        zVec);
-                        Vector256<float> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)),
-                                                                       Vector256.LoadUnsafe(ref yRef, remainder - (uint)(Vector256<float>.Count)),
+                        Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
+                                                                       Vector256.LoadUnsafe(ref yRef, remainder - (uint)Vector256<T>.Count),
                                                                        zVec);
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
 
                         break;
                     }
@@ -8004,7 +8061,7 @@ static void Vectorized512Small(ref float xRef, ref float yRef, float z, ref floa
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                        Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
                                                                        Vector256.LoadUnsafe(ref yRef),
                                                                        Vector256.Create(z));
                         beg.StoreUnsafe(ref dRef);
@@ -8018,17 +8075,17 @@ static void Vectorized512Small(ref float xRef, ref float yRef, float z, ref floa
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> zVec = Vector128.Create(z);
+                        Vector128<T> zVec = Vector128.Create(z);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
                                                                        Vector128.LoadUnsafe(ref yRef),
                                                                        zVec);
-                        Vector128<float> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
-                                                                       Vector128.LoadUnsafe(ref yRef, remainder - (uint)(Vector128<float>.Count)),
+                        Vector128<T> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
+                                                                       Vector128.LoadUnsafe(ref yRef, remainder - (uint)Vector128<T>.Count),
                                                                        zVec);
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -8037,7 +8094,7 @@ static void Vectorized512Small(ref float xRef, ref float yRef, float z, ref floa
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
                                                                        Vector128.LoadUnsafe(ref yRef),
                                                                        Vector128.Create(z));
                         beg.StoreUnsafe(ref dRef);
@@ -8079,13 +8136,14 @@ static void Vectorized512Small(ref float xRef, ref float yRef, float z, ref floa
         /// Performs an element-wise operation on <paramref name="x"/>, <paramref name="y"/>, and <paramref name="z"/>,
         /// and writes the results to <paramref name="destination"/>.
         /// </summary>
+        /// <typeparam name="T">The element type.</typeparam>
         /// <typeparam name="TTernaryOperator">
         /// Specifies the operation to perform on the pair-wise element loaded from <paramref name="x"/>, with <paramref name="y"/>,
         /// and the element loaded from <paramref name="z"/>.
         /// </typeparam>
-        private static void InvokeSpanScalarSpanIntoSpan<TTernaryOperator>(
-            ReadOnlySpan<float> x, float y, ReadOnlySpan<float> z, Span<float> destination)
-            where TTernaryOperator : struct, ITernaryOperator
+        private static void InvokeSpanScalarSpanIntoSpan<T, TTernaryOperator>(
+            ReadOnlySpan<T> x, T y, ReadOnlySpan<T> z, Span<T> destination)
+            where TTernaryOperator : struct, ITernaryOperator<T>
         {
             if (x.Length != z.Length)
             {
@@ -8105,15 +8163,15 @@ private static void InvokeSpanScalarSpanIntoSpan<TTernaryOperator>(
             // in a way that allows us to have the minimum possible
             // for small sizes
 
-            ref float xRef = ref MemoryMarshal.GetReference(x);
-            ref float zRef = ref MemoryMarshal.GetReference(z);
-            ref float dRef = ref MemoryMarshal.GetReference(destination);
+            ref T xRef = ref MemoryMarshal.GetReference(x);
+            ref T zRef = ref MemoryMarshal.GetReference(z);
+            ref T dRef = ref MemoryMarshal.GetReference(destination);
 
-            nuint remainder = (uint)(x.Length);
+            nuint remainder = (uint)x.Length;
 
-            if (Vector512.IsHardwareAccelerated)
+            if (Vector512.IsHardwareAccelerated && Vector512<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector512<float>.Count))
+                if (remainder >= (uint)Vector512<T>.Count)
                 {
                     Vectorized512(ref xRef, y, ref zRef, ref dRef, remainder);
                 }
@@ -8129,9 +8187,9 @@ private static void InvokeSpanScalarSpanIntoSpan<TTernaryOperator>(
                 return;
             }
 
-            if (Vector256.IsHardwareAccelerated)
+            if (Vector256.IsHardwareAccelerated && Vector256<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector256<float>.Count))
+                if (remainder >= (uint)Vector256<T>.Count)
                 {
                     Vectorized256(ref xRef, y, ref zRef, ref dRef, remainder);
                 }
@@ -8147,9 +8205,9 @@ private static void InvokeSpanScalarSpanIntoSpan<TTernaryOperator>(
                 return;
             }
 
-            if (Vector128.IsHardwareAccelerated)
+            if (Vector128.IsHardwareAccelerated && Vector128<T>.IsSupported && Unsafe.SizeOf<T>() >= 4)
             {
-                if (remainder >= (uint)(Vector128<float>.Count))
+                if (remainder >= (uint)Vector128<T>.Count)
                 {
                     Vectorized128(ref xRef, y, ref zRef, ref dRef, remainder);
                 }
@@ -8171,7 +8229,7 @@ private static void InvokeSpanScalarSpanIntoSpan<TTernaryOperator>(
             SoftwareFallback(ref xRef, y, ref zRef, ref dRef, remainder);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void SoftwareFallback(ref float xRef, float y, ref float zRef, ref float dRef, nuint length)
+            static void SoftwareFallback(ref T xRef, T y, ref T zRef, ref T dRef, nuint length)
             {
                 for (nuint i = 0; i < length; i++)
                 {
@@ -8181,39 +8239,39 @@ static void SoftwareFallback(ref float xRef, float y, ref float zRef, ref float
                 }
             }
 
-            static void Vectorized128(ref float xRef, float y, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized128(ref T xRef, T y, ref T zRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector128<float> yVec = Vector128.Create(y);
+                Vector128<T> yVec = Vector128.Create(y);
 
-                Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
                                                                yVec,
                                                                Vector128.LoadUnsafe(ref zRef));
-                Vector128<float> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
+                Vector128<T> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
                                                                yVec,
-                                                               Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count)));
+                                                               Vector128.LoadUnsafe(ref zRef, remainder - (uint)Vector128<T>.Count));
 
-                if (remainder > (uint)(Vector128<float>.Count * 8))
+                if (remainder > (uint)(Vector128<T>.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 (float* px = &xRef)
-                    fixed (float* pz = &zRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* pz = &zRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* zPtr = pz;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* zPtr = pz;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -8223,131 +8281,131 @@ static void Vectorized128(ref float xRef, float y, ref float zRef, ref float dRe
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector128<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector128<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector128<T>) - ((nuint)dPtr % (uint)sizeof(Vector128<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             zPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector128<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector128<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector128<float> vector1;
-                        Vector128<float> vector2;
-                        Vector128<float> vector3;
-                        Vector128<float> vector4;
+                        Vector128<T> vector1;
+                        Vector128<T> vector2;
+                        Vector128<T> vector3;
+                        Vector128<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 3)));
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 3)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 7)));
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 7)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector128<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                zPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                zPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector128<float>.Count * 8))
+                            while (remainder >= (uint)(Vector128<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 0)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 1)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 1)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 2)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 2)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 3)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 3)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 3)));
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 3)));
 
-                                vector1.Store(dPtr + (uint)(Vector128<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 4)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 5)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 5)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 6)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 6)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<float>.Count * 7)),
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector128.Load(xPtr + (uint)(Vector128<T>.Count * 7)),
                                                                   yVec,
-                                                                  Vector128.Load(zPtr + (uint)(Vector128<float>.Count * 7)));
+                                                                  Vector128.Load(zPtr + (uint)(Vector128<T>.Count * 7)));
 
-                                vector1.Store(dPtr + (uint)(Vector128<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector128<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector128<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector128<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector128<float>.Count * 8);
-                                zPtr += (uint)(Vector128<float>.Count * 8);
-                                dPtr += (uint)(Vector128<float>.Count * 8);
+                                xPtr += (uint)(Vector128<T>.Count * 8);
+                                zPtr += (uint)(Vector128<T>.Count * 8);
+                                dPtr += (uint)(Vector128<T>.Count * 8);
 
-                                remainder -= (uint)(Vector128<float>.Count * 8);
+                                remainder -= (uint)(Vector128<T>.Count * 8);
                             }
                         }
 
@@ -8367,77 +8425,77 @@ static void Vectorized128(ref float xRef, float y, ref float zRef, ref float dRe
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector128<float>.Count - 1)) & (nuint)(-Vector128<float>.Count);
+                remainder = (remainder + (uint)(Vector128<T>.Count - 1)) & (nuint)(-Vector128<T>.Count);
 
-                switch (remainder / (uint)(Vector128<float>.Count))
+                switch (remainder / (uint)Vector128<T>.Count)
                 {
                     case 8:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 8)),
+                        Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 8)),
                                                                           yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 8));
+                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 7)),
+                        Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 7)),
                                                                           yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 7));
+                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 6)),
+                        Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 6)),
                                                                           yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 6));
+                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 5)),
+                        Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 5)),
                                                                           yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 5));
+                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 4)),
+                        Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 4)),
                                                                           yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 4));
+                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 3)),
+                        Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 3)),
                                                                           yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 3));
+                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 3)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector128<float> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count * 2)),
+                        Vector128<T> vector = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<T>.Count * 2)),
                                                                           yVec,
-                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count * 2));
+                                                                          Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<T>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector128<T>.Count);
                         goto case 0;
                     }
 
@@ -8451,7 +8509,7 @@ static void Vectorized128(ref float xRef, float y, ref float zRef, ref float dRe
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized128Small(ref float xRef, float y, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized128Small(ref T xRef, T y, ref T zRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -8484,39 +8542,39 @@ static void Vectorized128Small(ref float xRef, float y, ref float zRef, ref floa
                 }
             }
 
-            static void Vectorized256(ref float xRef, float y, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized256(ref T xRef, T y, ref T zRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector256<float> yVec = Vector256.Create(y);
+                Vector256<T> yVec = Vector256.Create(y);
 
-                Vector256<float> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
                                                                yVec,
                                                                Vector256.LoadUnsafe(ref zRef));
-                Vector256<float> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)),
+                Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
                                                                yVec,
-                                                               Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count)));
+                                                               Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count));
 
-                if (remainder > (uint)(Vector256<float>.Count * 8))
+                if (remainder > (uint)(Vector256<T>.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 (float* px = &xRef)
-                    fixed (float* pz = &zRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* pz = &zRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* zPtr = pz;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* zPtr = pz;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -8526,131 +8584,131 @@ static void Vectorized256(ref float xRef, float y, ref float zRef, ref float dRe
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector256<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector256<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector256<T>) - ((nuint)dPtr % (uint)sizeof(Vector256<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             zPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector256<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector256<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector256<float> vector1;
-                        Vector256<float> vector2;
-                        Vector256<float> vector3;
-                        Vector256<float> vector4;
+                        Vector256<T> vector1;
+                        Vector256<T> vector2;
+                        Vector256<T> vector3;
+                        Vector256<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 3)));
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 3)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 7)));
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 7)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector256<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                zPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                zPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector256<float>.Count * 8))
+                            while (remainder >= (uint)(Vector256<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 0)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 1)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 1)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 2)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 2)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 3)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 3)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 3)));
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 3)));
 
-                                vector1.Store(dPtr + (uint)(Vector256<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 4)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 5)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 5)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 6)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 6)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<float>.Count * 7)),
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector256.Load(xPtr + (uint)(Vector256<T>.Count * 7)),
                                                                   yVec,
-                                                                  Vector256.Load(zPtr + (uint)(Vector256<float>.Count * 7)));
+                                                                  Vector256.Load(zPtr + (uint)(Vector256<T>.Count * 7)));
 
-                                vector1.Store(dPtr + (uint)(Vector256<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector256<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector256<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector256<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector256<float>.Count * 8);
-                                zPtr += (uint)(Vector256<float>.Count * 8);
-                                dPtr += (uint)(Vector256<float>.Count * 8);
+                                xPtr += (uint)(Vector256<T>.Count * 8);
+                                zPtr += (uint)(Vector256<T>.Count * 8);
+                                dPtr += (uint)(Vector256<T>.Count * 8);
 
-                                remainder -= (uint)(Vector256<float>.Count * 8);
+                                remainder -= (uint)(Vector256<T>.Count * 8);
                             }
                         }
 
@@ -8670,77 +8728,77 @@ static void Vectorized256(ref float xRef, float y, ref float zRef, ref float dRe
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector256<float>.Count - 1)) & (nuint)(-Vector256<float>.Count);
+                remainder = (remainder + (uint)(Vector256<T>.Count - 1)) & (nuint)(-Vector256<T>.Count);
 
-                switch (remainder / (uint)(Vector256<float>.Count))
+                switch (remainder / (uint)Vector256<T>.Count)
                 {
                     case 8:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 8)),
+                        Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 8)),
                                                                           yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 8));
+                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 7)),
+                        Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 7)),
                                                                           yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 7));
+                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 6)),
+                        Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 6)),
                                                                           yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 6));
+                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 5)),
+                        Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 5)),
                                                                           yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 5));
+                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 4)),
+                        Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 4)),
                                                                           yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 4));
+                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 3)),
+                        Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 3)),
                                                                           yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 3));
+                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 3)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector256<float> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count * 2)),
+                        Vector256<T> vector = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<T>.Count * 2)),
                                                                           yVec,
-                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count * 2));
+                                                                          Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<T>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector256<T>.Count);
                         goto case 0;
                     }
 
@@ -8754,7 +8812,7 @@ static void Vectorized256(ref float xRef, float y, ref float zRef, ref float dRe
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized256Small(ref float xRef, float y, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized256Small(ref T xRef, T y, ref T zRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -8764,17 +8822,17 @@ static void Vectorized256Small(ref float xRef, float y, ref float zRef, ref floa
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> yVec = Vector128.Create(y);
+                        Vector128<T> yVec = Vector128.Create(y);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
                                                                        yVec,
                                                                        Vector128.LoadUnsafe(ref zRef));
-                        Vector128<float> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
+                        Vector128<T> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
                                                                        yVec,
-                                                                       Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count)));
+                                                                       Vector128.LoadUnsafe(ref zRef, remainder - (uint)Vector128<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -8783,7 +8841,7 @@ static void Vectorized256Small(ref float xRef, float y, ref float zRef, ref floa
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
                                                                        Vector128.Create(y),
                                                                        Vector128.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
@@ -8820,39 +8878,39 @@ static void Vectorized256Small(ref float xRef, float y, ref float zRef, ref floa
                 }
             }
 
-            static void Vectorized512(ref float xRef, float y, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized512(ref T xRef, T y, ref T zRef, ref T dRef, nuint remainder)
             {
-                ref float dRefBeg = ref dRef;
+                ref T dRefBeg = ref dRef;
 
                 // Preload the beginning and end so that overlapping accesses don't negatively impact the data
 
-                Vector512<float> yVec = Vector512.Create(y);
+                Vector512<T> yVec = Vector512.Create(y);
 
-                Vector512<float> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef),
+                Vector512<T> beg = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef),
                                                                yVec,
                                                                Vector512.LoadUnsafe(ref zRef));
-                Vector512<float> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count)),
+                Vector512<T> end = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)Vector512<T>.Count),
                                                                yVec,
-                                                               Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count)));
+                                                               Vector512.LoadUnsafe(ref zRef, remainder - (uint)Vector512<T>.Count));
 
-                if (remainder > (uint)(Vector512<float>.Count * 8))
+                if (remainder > (uint)(Vector512<T>.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 (float* px = &xRef)
-                    fixed (float* pz = &zRef)
-                    fixed (float* pd = &dRef)
+                    fixed (T* px = &xRef)
+                    fixed (T* pz = &zRef)
+                    fixed (T* pd = &dRef)
                     {
-                        float* xPtr = px;
-                        float* zPtr = pz;
-                        float* dPtr = pd;
+                        T* xPtr = px;
+                        T* zPtr = pz;
+                        T* 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) % sizeof(float)) == 0;
+                        bool canAlign = ((nuint)dPtr % (nuint)sizeof(T)) == 0;
 
                         if (canAlign)
                         {
@@ -8862,131 +8920,131 @@ static void Vectorized512(ref float xRef, float y, ref float zRef, ref float dRe
                             // are more expensive than unaligned loads and aligning both is significantly more
                             // complex.
 
-                            nuint misalignment = ((uint)(sizeof(Vector512<float>)) - ((nuint)(dPtr) % (uint)(sizeof(Vector512<float>)))) / sizeof(float);
+                            nuint misalignment = ((uint)sizeof(Vector512<T>) - ((nuint)dPtr % (uint)sizeof(Vector512<T>))) / (uint)sizeof(T);
 
                             xPtr += misalignment;
                             zPtr += misalignment;
                             dPtr += misalignment;
 
-                            Debug.Assert(((nuint)(dPtr) % (uint)(sizeof(Vector512<float>))) == 0);
+                            Debug.Assert(((nuint)dPtr % (uint)sizeof(Vector512<T>)) == 0);
 
                             remainder -= misalignment;
                         }
 
-                        Vector512<float> vector1;
-                        Vector512<float> vector2;
-                        Vector512<float> vector3;
-                        Vector512<float> vector4;
+                        Vector512<T> vector1;
+                        Vector512<T> vector2;
+                        Vector512<T> vector3;
+                        Vector512<T> vector4;
 
-                        if ((remainder > (NonTemporalByteThreshold / sizeof(float))) && canAlign)
+                        if ((remainder > (NonTemporalByteThreshold / (nuint)sizeof(T))) && 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<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 3)));
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 3)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 7)));
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 7)));
 
-                                vector1.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.StoreAlignedNonTemporal(dPtr + (uint)(Vector512<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                zPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                zPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
                         else
                         {
-                            while (remainder >= (uint)(Vector512<float>.Count * 8))
+                            while (remainder >= (uint)(Vector512<T>.Count * 8))
                             {
                                 // We load, process, and store the first four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 0)),
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 0)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 0)));
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 1)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 0)));
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 1)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 1)));
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 2)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 1)));
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 2)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 2)));
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 3)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 2)));
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 3)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 3)));
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 3)));
 
-                                vector1.Store(dPtr + (uint)(Vector512<float>.Count * 0));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 1));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 2));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.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));
 
                                 // We load, process, and store the next four vectors
 
-                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 4)),
+                                vector1 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 4)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 4)));
-                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 5)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 4)));
+                                vector2 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 5)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 5)));
-                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 6)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 5)));
+                                vector3 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 6)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 6)));
-                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<float>.Count * 7)),
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 6)));
+                                vector4 = TTernaryOperator.Invoke(Vector512.Load(xPtr + (uint)(Vector512<T>.Count * 7)),
                                                                   yVec,
-                                                                  Vector512.Load(zPtr + (uint)(Vector512<float>.Count * 7)));
+                                                                  Vector512.Load(zPtr + (uint)(Vector512<T>.Count * 7)));
 
-                                vector1.Store(dPtr + (uint)(Vector512<float>.Count * 4));
-                                vector2.Store(dPtr + (uint)(Vector512<float>.Count * 5));
-                                vector3.Store(dPtr + (uint)(Vector512<float>.Count * 6));
-                                vector4.Store(dPtr + (uint)(Vector512<float>.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));
 
                                 // We adjust the source and destination references, then update
                                 // the count of remaining elements to process.
 
-                                xPtr += (uint)(Vector512<float>.Count * 8);
-                                zPtr += (uint)(Vector512<float>.Count * 8);
-                                dPtr += (uint)(Vector512<float>.Count * 8);
+                                xPtr += (uint)(Vector512<T>.Count * 8);
+                                zPtr += (uint)(Vector512<T>.Count * 8);
+                                dPtr += (uint)(Vector512<T>.Count * 8);
 
-                                remainder -= (uint)(Vector512<float>.Count * 8);
+                                remainder -= (uint)(Vector512<T>.Count * 8);
                             }
                         }
 
@@ -9006,77 +9064,77 @@ static void Vectorized512(ref float xRef, float y, ref float zRef, ref float dRe
                 // data before the first aligned address.
 
                 nuint endIndex = remainder;
-                remainder = (remainder + (uint)(Vector512<float>.Count - 1)) & (nuint)(-Vector512<float>.Count);
+                remainder = (remainder + (uint)(Vector512<T>.Count - 1)) & (nuint)(-Vector512<T>.Count);
 
-                switch (remainder / (uint)(Vector512<float>.Count))
+                switch (remainder / (uint)Vector512<T>.Count)
                 {
                     case 8:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 8)),
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 8)),
                                                                           yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 8)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 8));
+                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 8)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 8));
                         goto case 7;
                     }
 
                     case 7:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 7)),
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 7)),
                                                                           yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 7)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 7));
+                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 7)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 7));
                         goto case 6;
                     }
 
                     case 6:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 6)),
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 6)),
                                                                           yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 6)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 6));
+                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 6)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 6));
                         goto case 5;
                     }
 
                     case 5:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 5)),
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 5)),
                                                                           yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 5)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 5));
+                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 5)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 5));
                         goto case 4;
                     }
 
                     case 4:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 4)),
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 4)),
                                                                           yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 4)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 4));
+                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 4)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 4));
                         goto case 3;
                     }
 
                     case 3:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 3)),
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 3)),
                                                                           yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 3)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 3));
+                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 3)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.Count * 3));
                         goto case 2;
                     }
 
                     case 2:
                     {
-                        Vector512<float> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<float>.Count * 2)),
+                        Vector512<T> vector = TTernaryOperator.Invoke(Vector512.LoadUnsafe(ref xRef, remainder - (uint)(Vector512<T>.Count * 2)),
                                                                           yVec,
-                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<float>.Count * 2)));
-                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<float>.Count * 2));
+                                                                          Vector512.LoadUnsafe(ref zRef, remainder - (uint)(Vector512<T>.Count * 2)));
+                        vector.StoreUnsafe(ref dRef, remainder - (uint)(Vector512<T>.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<float>.Count);
+                        end.StoreUnsafe(ref dRef, endIndex - (uint)Vector512<T>.Count);
                         goto case 0;
                     }
 
@@ -9090,7 +9148,7 @@ static void Vectorized512(ref float xRef, float y, ref float zRef, ref float dRe
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            static void Vectorized512Small(ref float xRef, float y, ref float zRef, ref float dRef, nuint remainder)
+            static void Vectorized512Small(ref T xRef, T y, ref T zRef, ref T dRef, nuint remainder)
             {
                 switch (remainder)
                 {
@@ -9104,17 +9162,17 @@ static void Vectorized512Small(ref float xRef, float y, ref float zRef, ref floa
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> yVec = Vector256.Create(y);
+                        Vector256<T> yVec = Vector256.Create(y);
 
-                        Vector256<float> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                        Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
                                                                        yVec,
                                                                        Vector256.LoadUnsafe(ref zRef));
-                        Vector256<float> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)(Vector256<float>.Count)),
+                        Vector256<T> end = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef, remainder - (uint)Vector256<T>.Count),
                                                                        yVec,
-                                                                       Vector256.LoadUnsafe(ref zRef, remainder - (uint)(Vector256<float>.Count)));
+                                                                       Vector256.LoadUnsafe(ref zRef, remainder - (uint)Vector256<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector256<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector256<T>.Count);
 
                         break;
                     }
@@ -9123,7 +9181,7 @@ static void Vectorized512Small(ref float xRef, float y, ref float zRef, ref floa
                     {
                         Debug.Assert(Vector256.IsHardwareAccelerated);
 
-                        Vector256<float> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
+                        Vector256<T> beg = TTernaryOperator.Invoke(Vector256.LoadUnsafe(ref xRef),
                                                                        Vector256.Create(y),
                                                                        Vector256.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
@@ -9137,17 +9195,17 @@ static void Vectorized512Small(ref float xRef, float y, ref float zRef, ref floa
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> yVec = Vector128.Create(y);
+                        Vector128<T> yVec = Vector128.Create(y);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
                                                                        yVec,
                                                                        Vector128.LoadUnsafe(ref zRef));
-                        Vector128<float> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)(Vector128<float>.Count)),
+                        Vector128<T> end = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef, remainder - (uint)Vector128<T>.Count),
                                                                        yVec,
-                                                                       Vector128.LoadUnsafe(ref zRef, remainder - (uint)(Vector128<float>.Count)));
+                                                                       Vector128.LoadUnsafe(ref zRef, remainder - (uint)Vector128<T>.Count));
 
                         beg.StoreUnsafe(ref dRef);
-                        end.StoreUnsafe(ref dRef, remainder - (uint)(Vector128<float>.Count));
+                        end.StoreUnsafe(ref dRef, remainder - (uint)Vector128<T>.Count);
 
                         break;
                     }
@@ -9156,7 +9214,7 @@ static void Vectorized512Small(ref float xRef, float y, ref float zRef, ref floa
                     {
                         Debug.Assert(Vector128.IsHardwareAccelerated);
 
-                        Vector128<float> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
+                        Vector128<T> beg = TTernaryOperator.Invoke(Vector128.LoadUnsafe(ref xRef),
                                                                        Vector128.Create(y),
                                                                        Vector128.LoadUnsafe(ref zRef));
                         beg.StoreUnsafe(ref dRef);
@@ -9196,16 +9254,42 @@ static void Vectorized512Small(ref float xRef, float y, ref float zRef, ref floa
 
         /// <summary>Performs (x * y) + z. It will be rounded as one ternary operation if such an operation is accelerated on the current hardware.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector128<float> FusedMultiplyAdd(Vector128<float> x, Vector128<float> y, Vector128<float> addend)
+        private static T FusedMultiplyAdd<T>(T x, T y, T addend) where T : INumberBase<T>
+        {
+            if (typeof(T) == typeof(Half))
+            {
+                Half result = Half.FusedMultiplyAdd(Unsafe.As<T, Half>(ref x), Unsafe.As<T, Half>(ref y), Unsafe.As<T, Half>(ref addend));
+                return Unsafe.As<Half, T>(ref result);
+            }
+
+            if (typeof(T) == typeof(float))
+            {
+                float result = float.FusedMultiplyAdd(Unsafe.As<T, float>(ref x), Unsafe.As<T, float>(ref y), Unsafe.As<T, float>(ref addend));
+                return Unsafe.As<float, T>(ref result);
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                double result = double.FusedMultiplyAdd(Unsafe.As<T, double>(ref x), Unsafe.As<T, double>(ref y), Unsafe.As<T, double>(ref addend));
+                return Unsafe.As<double, T>(ref result);
+            }
+
+            return (x * y) + addend;
+        }
+
+        /// <summary>Performs (x * y) + z. It will be rounded as one ternary operation if such an operation is accelerated on the current hardware.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static Vector128<T> FusedMultiplyAdd<T>(Vector128<T> x, Vector128<T> y, Vector128<T> addend) where T : INumberBase<T>
         {
             if (Fma.IsSupported)
             {
-                return Fma.MultiplyAdd(x, y, addend);
+                if (typeof(T) == typeof(float)) return Fma.MultiplyAdd(x.AsSingle(), y.AsSingle(), addend.AsSingle()).As<float, T>();
+                if (typeof(T) == typeof(double)) return Fma.MultiplyAdd(x.AsDouble(), y.AsDouble(), addend.AsDouble()).As<double, T>();
             }
 
             if (AdvSimd.IsSupported)
             {
-                return AdvSimd.FusedMultiplyAdd(addend, x, y);
+                if (typeof(T) == typeof(float)) return AdvSimd.FusedMultiplyAdd(addend.AsSingle(), x.AsSingle(), y.AsSingle()).As<float, T>();
             }
 
             return (x * y) + addend;
@@ -9213,11 +9297,12 @@ private static Vector128<float> FusedMultiplyAdd(Vector128<float> x, Vector128<f
 
         /// <summary>Performs (x * y) + z. It will be rounded as one ternary operation if such an operation is accelerated on the current hardware.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector256<float> FusedMultiplyAdd(Vector256<float> x, Vector256<float> y, Vector256<float> addend)
+        private static Vector256<T> FusedMultiplyAdd<T>(Vector256<T> x, Vector256<T> y, Vector256<T> addend) where T : INumberBase<T>
         {
             if (Fma.IsSupported)
             {
-                return Fma.MultiplyAdd(x, y, addend);
+                if (typeof(T) == typeof(float)) return Fma.MultiplyAdd(x.AsSingle(), y.AsSingle(), addend.AsSingle()).As<float, T>();
+                if (typeof(T) == typeof(double)) return Fma.MultiplyAdd(x.AsDouble(), y.AsDouble(), addend.AsDouble()).As<double, T>();
             }
 
             return (x * y) + addend;
@@ -9225,58 +9310,123 @@ private static Vector256<float> FusedMultiplyAdd(Vector256<float> x, Vector256<f
 
         /// <summary>Performs (x * y) + z. It will be rounded as one ternary operation if such an operation is accelerated on the current hardware.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector512<float> FusedMultiplyAdd(Vector512<float> x, Vector512<float> y, Vector512<float> addend)
+        private static Vector512<T> FusedMultiplyAdd<T>(Vector512<T> x, Vector512<T> y, Vector512<T> addend) where T : INumberBase<T>
         {
             if (Avx512F.IsSupported)
             {
-                return Avx512F.FusedMultiplyAdd(x, y, addend);
+                if (typeof(T) == typeof(float)) return Avx512F.FusedMultiplyAdd(x.AsSingle(), y.AsSingle(), addend.AsSingle()).As<float, T>();
+                if (typeof(T) == typeof(double)) return Avx512F.FusedMultiplyAdd(x.AsDouble(), y.AsDouble(), addend.AsDouble()).As<double, T>();
             }
 
             return (x * y) + addend;
         }
 
         /// <summary>Aggregates all of the elements in the <paramref name="x"/> into a single value.</summary>
+        /// <typeparam name="T">The element type.</typeparam>
         /// <typeparam name="TAggregate">Specifies the operation to be performed on each pair of values.</typeparam>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static float HorizontalAggregate<TAggregate>(Vector128<float> x) where TAggregate : struct, IBinaryOperator
+        private static T HorizontalAggregate<T, TAggregate>(Vector128<T> x) where TAggregate : struct, IBinaryOperator<T>
         {
             // We need to do log2(count) operations to compute the total sum
 
-            x = TAggregate.Invoke(x, Vector128.Shuffle(x, Vector128.Create(2, 3, 0, 1)));
-            x = TAggregate.Invoke(x, Vector128.Shuffle(x, Vector128.Create(1, 0, 3, 2)));
+            if (Unsafe.SizeOf<T>() == 1)
+            {
+                x = TAggregate.Invoke(x, Vector128.Shuffle(x.AsByte(), Vector128.Create((byte)8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7)).As<byte, T>());
+                x = TAggregate.Invoke(x, Vector128.Shuffle(x.AsByte(), Vector128.Create((byte)4, 5, 6, 7, 0, 1, 2, 3, 8, 9, 10, 11, 12, 13, 14, 15)).As<byte, T>());
+                x = TAggregate.Invoke(x, Vector128.Shuffle(x.AsByte(), Vector128.Create((byte)2, 3, 0, 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)).As<byte, T>());
+                x = TAggregate.Invoke(x, Vector128.Shuffle(x.AsByte(), Vector128.Create((byte)1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)).As<byte, T>());
+            }
+            else if (Unsafe.SizeOf<T>() == 2)
+            {
+                x = TAggregate.Invoke(x, Vector128.Shuffle(x.AsInt16(), Vector128.Create(4, 5, 6, 7, 0, 1, 2, 3)).As<short, T>());
+                x = TAggregate.Invoke(x, Vector128.Shuffle(x.AsInt16(), Vector128.Create(2, 3, 0, 1, 4, 5, 6, 7)).As<short, T>());
+                x = TAggregate.Invoke(x, Vector128.Shuffle(x.AsInt16(), Vector128.Create(1, 0, 2, 3, 4, 5, 6, 7)).As<short, T>());
+            }
+            else if (Unsafe.SizeOf<T>() == 4)
+            {
+                x = TAggregate.Invoke(x, Vector128.Shuffle(x.AsInt32(), Vector128.Create(2, 3, 0, 1)).As<int, T>());
+                x = TAggregate.Invoke(x, Vector128.Shuffle(x.AsInt32(), Vector128.Create(1, 0, 3, 2)).As<int, T>());
+            }
+            else if (Unsafe.SizeOf<T>() == 8)
+            {
+                x = TAggregate.Invoke(x, Vector128.Shuffle(x.AsInt64(), Vector128.Create(1, 0)).As<long, T>());
+            }
+            else
+            {
+                Debug.Fail("Should not be reachable");
+                throw new NotSupportedException();
+            }
 
             return x.ToScalar();
         }
 
         /// <summary>Aggregates all of the elements in the <paramref name="x"/> into a single value.</summary>
+        /// <typeparam name="T">The element type.</typeparam>
         /// <typeparam name="TAggregate">Specifies the operation to be performed on each pair of values.</typeparam>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static float HorizontalAggregate<TAggregate>(Vector256<float> x) where TAggregate : struct, IBinaryOperator =>
-            HorizontalAggregate<TAggregate>(TAggregate.Invoke(x.GetLower(), x.GetUpper()));
+        private static T HorizontalAggregate<T, TAggregate>(Vector256<T> x) where TAggregate : struct, IBinaryOperator<T> =>
+            HorizontalAggregate<T, TAggregate>(TAggregate.Invoke(x.GetLower(), x.GetUpper()));
 
         /// <summary>Aggregates all of the elements in the <paramref name="x"/> into a single value.</summary>
+        /// <typeparam name="T">The element type.</typeparam>
         /// <typeparam name="TAggregate">Specifies the operation to be performed on each pair of values.</typeparam>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static float HorizontalAggregate<TAggregate>(Vector512<float> x) where TAggregate : struct, IBinaryOperator =>
-            HorizontalAggregate<TAggregate>(TAggregate.Invoke(x.GetLower(), x.GetUpper()));
+        private static T HorizontalAggregate<T, TAggregate>(Vector512<T> x) where TAggregate : struct, IBinaryOperator<T> =>
+            HorizontalAggregate<T, TAggregate>(TAggregate.Invoke(x.GetLower(), x.GetUpper()));
 
         /// <summary>Gets whether the specified <see cref="float"/> is negative.</summary>
-        private static bool IsNegative(float f) => float.IsNegative(f);
+        private static bool IsNegative<T>(T f) where T : INumberBase<T> => T.IsNegative(f);
 
         /// <summary>Gets whether each specified <see cref="float"/> is negative.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector128<float> IsNegative(Vector128<float> vector) =>
-            Vector128.LessThan(vector.AsInt32(), Vector128<int>.Zero).AsSingle();
+        private static Vector128<T> IsNegative<T>(Vector128<T> vector)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                return Vector128.LessThan(vector.AsInt32(), Vector128<int>.Zero).As<int, T>();
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                return Vector128.LessThan(vector.AsInt64(), Vector128<long>.Zero).As<long, T>();
+            }
+
+            return Vector128.LessThan(vector, Vector128<T>.Zero);
+        }
 
         /// <summary>Gets whether each specified <see cref="float"/> is negative.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector256<float> IsNegative(Vector256<float> vector) =>
-            Vector256.LessThan(vector.AsInt32(), Vector256<int>.Zero).AsSingle();
+        private static Vector256<T> IsNegative<T>(Vector256<T> vector)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                return Vector256.LessThan(vector.AsInt32(), Vector256<int>.Zero).As<int, T>();
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                return Vector256.LessThan(vector.AsInt64(), Vector256<long>.Zero).As<long, T>();
+            }
+
+            return Vector256.LessThan(vector, Vector256<T>.Zero);
+        }
 
         /// <summary>Gets whether each specified <see cref="float"/> is negative.</summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector512<float> IsNegative(Vector512<float> vector) =>
-            Vector512.LessThan(vector.AsInt32(), Vector512<int>.Zero).AsSingle();
+        private static Vector512<T> IsNegative<T>(Vector512<T> vector)
+        {
+            if (typeof(T) == typeof(float))
+            {
+                return Vector512.LessThan(vector.AsInt32(), Vector512<int>.Zero).As<int, T>();
+            }
+
+            if (typeof(T) == typeof(double))
+            {
+                return Vector512.LessThan(vector.AsInt64(), Vector512<long>.Zero).As<long, T>();
+            }
+
+            return Vector512.LessThan(vector, Vector512<T>.Zero);
+        }
 
         /// <summary>Gets whether the specified <see cref="float"/> is positive.</summary>
         private static bool IsPositive(float f) => float.IsPositive(f);
@@ -9296,183 +9446,411 @@ private static Vector256<float> IsPositive(Vector256<float> vector) =>
         private static Vector512<float> IsPositive(Vector512<float> vector) =>
             Vector512.GreaterThan(vector.AsInt32(), Vector512<int>.AllBitsSet).AsSingle();
 
-        /// <summary>Gets the base 2 logarithm of <paramref name="x"/>.</summary>
-        private static float Log2(float x) => MathF.Log2(x);
-
         /// <summary>
         /// Gets a vector mask that will be all-ones-set for the last <paramref name="count"/> elements
         /// and zero for all other elements.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector128<float> CreateAlignmentMaskSingleVector128(int count) =>
-            Vector128.LoadUnsafe(
-                ref Unsafe.As<uint, float>(ref MemoryMarshal.GetReference(AlignmentUInt32Mask_16x16)),
-                (uint)(count * 16)); // first four floats in the row
+        private static Vector128<T> CreateAlignmentMaskVector128<T>(int count)
+        {
+            if (Unsafe.SizeOf<T>() == 1)
+            {
+                return Vector128.LoadUnsafe(
+                    ref Unsafe.As<byte, T>(ref MemoryMarshal.GetReference(AlignmentByteMask_64x65)),
+                    (uint)(count * 64));
+            }
 
-        /// <summary>
-        /// Gets a vector mask that will be all-ones-set for the last <paramref name="count"/> elements
-        /// and zero for all other elements.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector256<float> CreateAlignmentMaskSingleVector256(int count) =>
-            Vector256.LoadUnsafe(
-                ref Unsafe.As<uint, float>(ref MemoryMarshal.GetReference(AlignmentUInt32Mask_16x16)),
-                (uint)(count * 16)); // first eight floats in the row
+            if (Unsafe.SizeOf<T>() == 2)
+            {
+                return Vector128.LoadUnsafe(
+                    ref Unsafe.As<ushort, T>(ref MemoryMarshal.GetReference(AlignmentUInt16Mask_32x33)),
+                    (uint)(count * 32));
+            }
 
-        /// <summary>
-        /// Gets a vector mask that will be all-ones-set for the last <paramref name="count"/> elements
-        /// and zero for all other elements.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector512<float> CreateAlignmentMaskSingleVector512(int count) =>
-            Vector512.LoadUnsafe(
-                ref Unsafe.As<uint, float>(ref MemoryMarshal.GetReference(AlignmentUInt32Mask_16x16)),
-                (uint)(count * 16)); // all sixteen floats in the row
+            if (Unsafe.SizeOf<T>() == 4)
+            {
+                return Vector128.LoadUnsafe(
+                    ref Unsafe.As<uint, T>(ref MemoryMarshal.GetReference(AlignmentUInt32Mask_16x17)),
+                    (uint)(count * 16));
+            }
+
+            if (Unsafe.SizeOf<T>() == 8)
+            {
+                return Vector128.LoadUnsafe(
+                    ref Unsafe.As<ulong, T>(ref MemoryMarshal.GetReference(AlignmentUInt64Mask_8x9)),
+                    (uint)(count * 8));
+            }
+
+            Debug.Fail("Shouldn't get here");
+            throw new NotSupportedException();
+        }
 
         /// <summary>
         /// Gets a vector mask that will be all-ones-set for the last <paramref name="count"/> elements
         /// and zero for all other elements.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector128<float> CreateRemainderMaskSingleVector128(int count) =>
-            Vector128.LoadUnsafe(
-                ref Unsafe.As<uint, float>(ref MemoryMarshal.GetReference(RemainderUInt32Mask_16x16)),
-                (uint)((count * 16) + 12)); // last four floats in the row
+        private static Vector256<T> CreateAlignmentMaskVector256<T>(int count)
+        {
+            if (Unsafe.SizeOf<T>() == 1)
+            {
+                return Vector256.LoadUnsafe(
+                    ref Unsafe.As<byte, T>(ref MemoryMarshal.GetReference(AlignmentByteMask_64x65)),
+                    (uint)(count * 64));
+            }
+
+            if (Unsafe.SizeOf<T>() == 2)
+            {
+                return Vector256.LoadUnsafe(
+                    ref Unsafe.As<ushort, T>(ref MemoryMarshal.GetReference(AlignmentUInt16Mask_32x33)),
+                    (uint)(count * 32));
+            }
+
+            if (Unsafe.SizeOf<T>() == 4)
+            {
+                return Vector256.LoadUnsafe(
+                    ref Unsafe.As<uint, T>(ref MemoryMarshal.GetReference(AlignmentUInt32Mask_16x17)),
+                    (uint)(count * 16));
+            }
+
+            if (Unsafe.SizeOf<T>() == 8)
+            {
+                return Vector256.LoadUnsafe(
+                    ref Unsafe.As<ulong, T>(ref MemoryMarshal.GetReference(AlignmentUInt64Mask_8x9)),
+                    (uint)(count * 8));
+            }
+
+            Debug.Fail("Shouldn't get here");
+            throw new NotSupportedException();
+        }
 
         /// <summary>
         /// Gets a vector mask that will be all-ones-set for the last <paramref name="count"/> elements
         /// and zero for all other elements.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector256<float> CreateRemainderMaskSingleVector256(int count) =>
-            Vector256.LoadUnsafe(
-                ref Unsafe.As<uint, float>(ref MemoryMarshal.GetReference(RemainderUInt32Mask_16x16)),
-                (uint)((count * 16) + 8)); // last eight floats in the row
+        private static Vector512<T> CreateAlignmentMaskVector512<T>(int count)
+        {
+            if (Unsafe.SizeOf<T>() == 1)
+            {
+                return Vector512.LoadUnsafe(
+                    ref Unsafe.As<byte, T>(ref MemoryMarshal.GetReference(AlignmentByteMask_64x65)),
+                    (uint)(count * 64));
+            }
+
+            if (Unsafe.SizeOf<T>() == 2)
+            {
+                return Vector512.LoadUnsafe(
+                    ref Unsafe.As<ushort, T>(ref MemoryMarshal.GetReference(AlignmentUInt16Mask_32x33)),
+                    (uint)(count * 32));
+            }
+
+            if (Unsafe.SizeOf<T>() == 4)
+            {
+                return Vector512.LoadUnsafe(
+                    ref Unsafe.As<uint, T>(ref MemoryMarshal.GetReference(AlignmentUInt32Mask_16x17)),
+                    (uint)(count * 16));
+            }
+
+            if (Unsafe.SizeOf<T>() == 8)
+            {
+                return Vector512.LoadUnsafe(
+                    ref Unsafe.As<ulong, T>(ref MemoryMarshal.GetReference(AlignmentUInt64Mask_8x9)),
+                    (uint)(count * 8));
+            }
+
+            Debug.Fail("Shouldn't get here - CreateAlignmentMaskVector512");
+            throw new NotSupportedException();
+        }
 
         /// <summary>
         /// Gets a vector mask that will be all-ones-set for the last <paramref name="count"/> elements
         /// and zero for all other elements.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector512<float> CreateRemainderMaskSingleVector512(int count) =>
-            Vector512.LoadUnsafe(
-                ref Unsafe.As<uint, float>(ref MemoryMarshal.GetReference(RemainderUInt32Mask_16x16)),
-                (uint)(count * 16)); // all sixteen floats in the row
-
-        /// <summary>x + y</summary>
-        private readonly struct AddOperator : IAggregationOperator
+        private static Vector128<T> CreateRemainderMaskVector128<T>(int count)
         {
-            public static float Invoke(float x, float y) => x + y;
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y) => x + y;
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y) => x + y;
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y) => x + y;
+            if (Unsafe.SizeOf<T>() == 1)
+            {
+                return Vector128.LoadUnsafe(
+                    ref Unsafe.As<byte, T>(ref MemoryMarshal.GetReference(RemainderByteMask_64x65)),
+                    (uint)(count * 64) + 48); // last 16 bytes in the row
+            }
+
+            if (Unsafe.SizeOf<T>() == 2)
+            {
+                return Vector128.LoadUnsafe(
+                    ref Unsafe.As<ushort, T>(ref MemoryMarshal.GetReference(RemainderUInt16Mask_32x33)),
+                    (uint)(count * 32) + 24); // last 8 shorts in the row
+            }
 
-            public static float Invoke(Vector128<float> x) => Vector128.Sum(x);
-            public static float Invoke(Vector256<float> x) => Vector256.Sum(x);
-            public static float Invoke(Vector512<float> x) => Vector512.Sum(x);
+            if (Unsafe.SizeOf<T>() == 4)
+            {
+                return Vector128.LoadUnsafe(
+                    ref Unsafe.As<uint, T>(ref MemoryMarshal.GetReference(RemainderUInt32Mask_16x17)),
+                    (uint)(count * 16) + 12); // last 4 ints in the row
+            }
 
-            public static float IdentityValue => 0;
-        }
+            if (Unsafe.SizeOf<T>() == 8)
+            {
+                return Vector128.LoadUnsafe(
+                    ref Unsafe.As<ulong, T>(ref MemoryMarshal.GetReference(RemainderUInt64Mask_8x9)),
+                    (uint)(count * 8) + 6); // last 2 longs in the row
+            }
 
-        /// <summary>x - y</summary>
-        private readonly struct SubtractOperator : IBinaryOperator
-        {
-            public static float Invoke(float x, float y) => x - y;
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y) => x - y;
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y) => x - y;
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y) => x - y;
+            Debug.Fail("Shouldn't get here - CreateRemainderMaskVector128");
+            throw new NotSupportedException();
         }
 
-        /// <summary>(x - y) * (x - y)</summary>
-        private readonly struct SubtractSquaredOperator : IBinaryOperator
+        /// <summary>
+        /// Gets a vector mask that will be all-ones-set for the last <paramref name="count"/> elements
+        /// and zero for all other elements.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static Vector256<T> CreateRemainderMaskVector256<T>(int count)
         {
-            public static float Invoke(float x, float y)
+            if (Unsafe.SizeOf<T>() == 1)
             {
-                float tmp = x - y;
-                return tmp * tmp;
+                return Vector256.LoadUnsafe(
+                    ref Unsafe.As<byte, T>(ref MemoryMarshal.GetReference(RemainderByteMask_64x65)),
+                    (uint)(count * 64) + 32); // last 32 bytes in the row
             }
 
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y)
+            if (Unsafe.SizeOf<T>() == 2)
             {
-                Vector128<float> tmp = x - y;
-                return tmp * tmp;
+                return Vector256.LoadUnsafe(
+                    ref Unsafe.As<ushort, T>(ref MemoryMarshal.GetReference(RemainderUInt16Mask_32x33)),
+                    (uint)(count * 32) + 16); // last 16 shorts in the row
             }
 
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y)
+            if (Unsafe.SizeOf<T>() == 4)
             {
-                Vector256<float> tmp = x - y;
-                return tmp * tmp;
+                return Vector256.LoadUnsafe(
+                    ref Unsafe.As<uint, T>(ref MemoryMarshal.GetReference(RemainderUInt32Mask_16x17)),
+                    (uint)(count * 16) + 8); // last 8 ints in the row
             }
 
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y)
+            if (Unsafe.SizeOf<T>() == 8)
             {
-                Vector512<float> tmp = x - y;
-                return tmp * tmp;
+                return Vector256.LoadUnsafe(
+                    ref Unsafe.As<ulong, T>(ref MemoryMarshal.GetReference(RemainderUInt64Mask_8x9)),
+                    (uint)(count * 8) + 4); // last 4 longs in the row
             }
-        }
-
-        /// <summary>x * y</summary>
-        private readonly struct MultiplyOperator : IAggregationOperator
-        {
-            public static float Invoke(float x, float y) => x * y;
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y) => x * y;
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y) => x * y;
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y) => x * y;
 
-            public static float Invoke(Vector128<float> x) => HorizontalAggregate<MultiplyOperator>(x);
-            public static float Invoke(Vector256<float> x) => HorizontalAggregate<MultiplyOperator>(x);
-            public static float Invoke(Vector512<float> x) => HorizontalAggregate<MultiplyOperator>(x);
-
-            public static float IdentityValue => 1;
+            Debug.Fail("Shouldn't get here - CreateRemainderMaskVector256");
+            throw new NotSupportedException();
         }
 
-        /// <summary>x / y</summary>
-        private readonly struct DivideOperator : IBinaryOperator
+        /// <summary>
+        /// Gets a vector mask that will be all-ones-set for the last <paramref name="count"/> elements
+        /// and zero for all other elements.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static Vector512<T> CreateRemainderMaskVector512<T>(int count)
         {
-            public static float Invoke(float x, float y) => x / y;
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y) => x / y;
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y) => x / y;
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y) => x / y;
+            if (Unsafe.SizeOf<T>() == 1)
+            {
+                return Vector512.LoadUnsafe(
+                    ref Unsafe.As<byte, T>(ref MemoryMarshal.GetReference(RemainderByteMask_64x65)),
+                    (uint)(count * 64));
+            }
+
+            if (Unsafe.SizeOf<T>() == 2)
+            {
+                return Vector512.LoadUnsafe(
+                    ref Unsafe.As<ushort, T>(ref MemoryMarshal.GetReference(RemainderUInt16Mask_32x33)),
+                    (uint)(count * 32));
+            }
+
+            if (Unsafe.SizeOf<T>() == 4)
+            {
+                return Vector512.LoadUnsafe(
+                    ref Unsafe.As<uint, T>(ref MemoryMarshal.GetReference(RemainderUInt32Mask_16x17)),
+                    (uint)(count * 16));
+            }
+
+            if (Unsafe.SizeOf<T>() == 8)
+            {
+                return Vector512.LoadUnsafe(
+                    ref Unsafe.As<ulong, T>(ref MemoryMarshal.GetReference(RemainderUInt64Mask_8x9)),
+                    (uint)(count * 8));
+            }
+
+            Debug.Fail("Shouldn't get here - CreateRemainderMaskVector512");
+            throw new NotSupportedException();
         }
 
-        /// <summary>MathF.Max(x, y) (but NaNs may not be propagated)</summary>
-        private readonly struct MaxOperator : IAggregationOperator
+        /// <summary>x + y</summary>
+        internal readonly struct AddOperator<T> : IAggregationOperator<T> where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
         {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static float Invoke(float x, float y) =>
-                x == y ?
-                    (IsNegative(x) ? y : x) :
-                    (y > x ? y : x);
+            public static T Invoke(T x, T y) => x + y;
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x + y;
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x + y;
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x + y;
+
+            public static T Invoke(Vector128<T> x) => Vector128.Sum(x);
+            public static T Invoke(Vector256<T> x) => Vector256.Sum(x);
+            public static T Invoke(Vector512<T> x) => Vector512.Sum(x);
+
+            public static T IdentityValue => T.AdditiveIdentity;
+        }
+
+        /// <summary>x - y</summary>
+        internal readonly struct SubtractOperator<T> : IBinaryOperator<T> where T : ISubtractionOperators<T, T, T>
+        {
+            public static T Invoke(T x, T y) => x - y;
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x - y;
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x - y;
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x - y;
+        }
+
+        /// <summary>(x - y) * (x - y)</summary>
+        internal readonly struct SubtractSquaredOperator<T> : IBinaryOperator<T> where T : ISubtractionOperators<T, T, T>, IMultiplyOperators<T, T, T>
+        {
+            public static T Invoke(T x, T y)
+            {
+                T tmp = x - y;
+                return tmp * tmp;
+            }
+
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y)
+            {
+                Vector128<T> tmp = x - y;
+                return tmp * tmp;
+            }
+
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
+            {
+                Vector256<T> tmp = x - y;
+                return tmp * tmp;
+            }
+
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
+            {
+                Vector512<T> tmp = x - y;
+                return tmp * tmp;
+            }
+        }
+
+        /// <summary>x * y</summary>
+        internal readonly struct MultiplyOperator<T> : IAggregationOperator<T> where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            public static T Invoke(T x, T y) => x * y;
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x * y;
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x * y;
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x * y;
+
+            public static T Invoke(Vector128<T> x) => HorizontalAggregate<T, MultiplyOperator<T>>(x);
+            public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MultiplyOperator<T>>(x);
+            public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MultiplyOperator<T>>(x);
+
+            public static T IdentityValue => T.MultiplicativeIdentity;
+        }
+
+        /// <summary>x / y</summary>
+        internal readonly struct DivideOperator<T> : IBinaryOperator<T> where T : IDivisionOperators<T, T, T>
+        {
+            public static T Invoke(T x, T y) => x / y;
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y) => x / y;
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y) => x / y;
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y) => x / y;
+        }
+
+        /// <summary>T.Max(x, y) (but NaNs may not be propagated)</summary>
+        internal readonly struct MaxOperator<T> : IAggregationOperator<T> where T : INumber<T>
+        {
+            public static T Invoke(T x, T y)
+            {
+                if (typeof(T) == typeof(Half) || typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    return x == y ?
+                        (IsNegative(x) ? y : x) :
+                        (y > x ? y : x);
+                }
+
+                return T.Max(x, y);
+            }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y)
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y)
             {
                 if (AdvSimd.IsSupported)
                 {
-                    return AdvSimd.Max(x, y);
+                    if (typeof(T) == typeof(byte)) return AdvSimd.Max(x.AsByte(), y.AsByte()).As<byte, T>();
+                    if (typeof(T) == typeof(sbyte)) return AdvSimd.Max(x.AsSByte(), y.AsSByte()).As<sbyte, T>();
+                    if (typeof(T) == typeof(short)) return AdvSimd.Max(x.AsInt16(), y.AsInt16()).As<short, T>();
+                    if (typeof(T) == typeof(ushort)) return AdvSimd.Max(x.AsUInt16(), y.AsUInt16()).As<ushort, T>();
+                    if (typeof(T) == typeof(int)) return AdvSimd.Max(x.AsInt32(), y.AsInt32()).As<int, T>();
+                    if (typeof(T) == typeof(uint)) return AdvSimd.Max(x.AsUInt32(), y.AsUInt32()).As<uint, T>();
+                    if (typeof(T) == typeof(float)) return AdvSimd.Max(x.AsSingle(), y.AsSingle()).As<float, T>();
                 }
 
-                return
-                    Vector128.ConditionalSelect(Vector128.Equals(x, y),
-                        Vector128.ConditionalSelect(IsNegative(x), y, x),
-                        Vector128.Max(x, y));
+                if (typeof(T) == typeof(float))
+                {
+                    return
+                        Vector128.ConditionalSelect(Vector128.Equals(x, y),
+                            Vector128.ConditionalSelect(IsNegative(x.AsSingle()).As<float, T>(), y, x),
+                            Vector128.Max(x, y));
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return
+                        Vector128.ConditionalSelect(Vector128.Equals(x, y),
+                            Vector128.ConditionalSelect(IsNegative(x.AsDouble()).As<double, T>(), y, x),
+                            Vector128.Max(x, y));
+                }
+
+                return Vector128.Max(x, y);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y) =>
-                Vector256.ConditionalSelect(Vector256.Equals(x, y),
-                    Vector256.ConditionalSelect(IsNegative(x), y, x),
-                    Vector256.Max(x, y));
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    return
+                        Vector256.ConditionalSelect(Vector256.Equals(x, y),
+                            Vector256.ConditionalSelect(IsNegative(x.AsSingle()).As<float, T>(), y, x),
+                            Vector256.Max(x, y));
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return
+                        Vector256.ConditionalSelect(Vector256.Equals(x, y),
+                            Vector256.ConditionalSelect(IsNegative(x.AsDouble()).As<double, T>(), y, x),
+                            Vector256.Max(x, y));
+                }
+
+                return Vector256.Max(x, y);
+            }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y) =>
-                Vector512.ConditionalSelect(Vector512.Equals(x, y),
-                    Vector512.ConditionalSelect(IsNegative(x), y, x),
-                    Vector512.Max(x, y));
-
-            public static float Invoke(Vector128<float> x) => HorizontalAggregate<MaxOperator>(x);
-            public static float Invoke(Vector256<float> x) => HorizontalAggregate<MaxOperator>(x);
-            public static float Invoke(Vector512<float> x) => HorizontalAggregate<MaxOperator>(x);
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
+            {
+                if (typeof(T) == typeof(float))
+                {
+                    return
+                        Vector512.ConditionalSelect(Vector512.Equals(x, y),
+                            Vector512.ConditionalSelect(IsNegative(x.AsSingle()).As<float, T>(), y, x),
+                            Vector512.Max(x, y));
+                }
+
+                if (typeof(T) == typeof(double))
+                {
+                    return
+                        Vector512.ConditionalSelect(Vector512.Equals(x, y),
+                            Vector512.ConditionalSelect(IsNegative(x.AsDouble()).As<double, T>(), y, x),
+                            Vector512.Max(x, y));
+                }
+
+                return Vector512.Max(x, y);
+            }
+
+            public static T Invoke(Vector128<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x);
+            public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x);
+            public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MaxOperator<T>>(x);
         }
 
         private interface IIndexOfOperator
@@ -9487,20 +9865,22 @@ private interface IIndexOfOperator
         }
 
         /// <summary>Returns the index of MathF.Max(x, y)</summary>
-        private readonly struct IndexOfMaxOperator : IIndexOfOperator
+        internal readonly struct IndexOfMaxOperator : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static int Invoke(Vector128<float> result, Vector128<int> maxIndex)
             {
-                Vector128<float> tmpResult = Vector128.Shuffle(result, Vector128.Create(2, 3, 0, 1));
-                Vector128<int> tmpIndex = Vector128.Shuffle(maxIndex, Vector128.Create(2, 3, 0, 1));
+                Vector128<float> tmpResult;
+                Vector128<int> tmpIndex;
 
+                tmpResult = Vector128.Shuffle(result, Vector128.Create(2, 3, 0, 1));
+                tmpIndex = Vector128.Shuffle(maxIndex, Vector128.Create(2, 3, 0, 1));
                 Invoke(ref result, tmpResult, ref maxIndex, tmpIndex);
 
                 tmpResult = Vector128.Shuffle(result, Vector128.Create(1, 0, 3, 2));
                 tmpIndex = Vector128.Shuffle(maxIndex, Vector128.Create(1, 0, 3, 2));
-
                 Invoke(ref result, tmpResult, ref maxIndex, tmpIndex);
+
                 return maxIndex.ToScalar();
             }
 
@@ -9604,7 +9984,7 @@ public static int Invoke(ref float result, float current, int resultIndex, int c
             }
         }
 
-        private readonly struct IndexOfMaxMagnitudeOperator : IIndexOfOperator
+        internal readonly struct IndexOfMaxMagnitudeOperator : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static int Invoke(Vector128<float> result, Vector128<int> maxIndex)
@@ -9730,7 +10110,7 @@ public static int Invoke(ref float result, float current, int resultIndex, int c
         }
 
         /// <summary>Returns the index of MathF.Min(x, y)</summary>
-        private readonly struct IndexOfMinOperator : IIndexOfOperator
+        internal readonly struct IndexOfMinOperator : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static int Invoke(Vector128<float> result, Vector128<int> resultIndex)
@@ -9848,7 +10228,7 @@ public static int Invoke(ref float result, float current, int resultIndex, int c
             }
         }
 
-        private readonly struct IndexOfMinMagnitudeOperator : IIndexOfOperator
+        internal readonly struct IndexOfMinMagnitudeOperator : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public static int Invoke(Vector128<float> result, Vector128<int> resultIndex)
@@ -9973,385 +10353,663 @@ public static int Invoke(ref float result, float current, int resultIndex, int c
             }
         }
 
-        /// <summary>MathF.Max(x, y)</summary>
-        private readonly struct MaxPropagateNaNOperator : IBinaryOperator
+        /// <summary>Max(x, y)</summary>
+        internal readonly struct MaxPropagateNaNOperator<T> : IBinaryOperator<T>
+             where T : INumber<T>
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static float Invoke(float x, float y) => MathF.Max(x, y);
+            public static T Invoke(T x, T y) => T.Max(x, y);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y)
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y)
             {
                 if (AdvSimd.IsSupported)
                 {
-                    return AdvSimd.Max(x, y);
+                    if (typeof(T) == typeof(byte)) return AdvSimd.Max(x.AsByte(), y.AsByte()).As<byte, T>();
+                    if (typeof(T) == typeof(sbyte)) return AdvSimd.Max(x.AsSByte(), y.AsSByte()).As<sbyte, T>();
+                    if (typeof(T) == typeof(ushort)) return AdvSimd.Max(x.AsUInt16(), y.AsUInt16()).As<ushort, T>();
+                    if (typeof(T) == typeof(short)) return AdvSimd.Max(x.AsInt16(), y.AsInt16()).As<short, T>();
+                    if (typeof(T) == typeof(uint)) return AdvSimd.Max(x.AsUInt32(), y.AsUInt32()).As<uint, T>();
+                    if (typeof(T) == typeof(int)) return AdvSimd.Max(x.AsInt32(), y.AsInt32()).As<int, T>();
+                    if (typeof(T) == typeof(float)) return AdvSimd.Max(x.AsSingle(), y.AsSingle()).As<float, T>();
                 }
 
-                return
-                    Vector128.ConditionalSelect(Vector128.Equals(x, x),
-                        Vector128.ConditionalSelect(Vector128.Equals(y, y),
-                            Vector128.ConditionalSelect(Vector128.Equals(x, y),
-                                Vector128.ConditionalSelect(IsNegative(x), y, x),
-                                Vector128.Max(x, y)),
-                            y),
-                        x);
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    return
+                        Vector128.ConditionalSelect(Vector128.Equals(x, x),
+                            Vector128.ConditionalSelect(Vector128.Equals(y, y),
+                                Vector128.ConditionalSelect(Vector128.Equals(x, y),
+                                    Vector128.ConditionalSelect(IsNegative(x), y, x),
+                                    Vector128.Max(x, y)),
+                                y),
+                            x);
+                }
+
+                return Vector128.Max(x, y);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y) =>
-                Vector256.ConditionalSelect(Vector256.Equals(x, x),
-                    Vector256.ConditionalSelect(Vector256.Equals(y, y),
-                        Vector256.ConditionalSelect(Vector256.Equals(x, y),
-                            Vector256.ConditionalSelect(IsNegative(x), y, x),
-                            Vector256.Max(x, y)),
-                        y),
-                    x);
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
+            {
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    return
+                        Vector256.ConditionalSelect(Vector256.Equals(x, x),
+                            Vector256.ConditionalSelect(Vector256.Equals(y, y),
+                                Vector256.ConditionalSelect(Vector256.Equals(x, y),
+                                    Vector256.ConditionalSelect(IsNegative(x), y, x),
+                                    Vector256.Max(x, y)),
+                                y),
+                            x);
+                }
+
+                return Vector256.Max(x, y);
+            }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y) =>
-                Vector512.ConditionalSelect(Vector512.Equals(x, x),
-                    Vector512.ConditionalSelect(Vector512.Equals(y, y),
-                        Vector512.ConditionalSelect(Vector512.Equals(x, y),
-                            Vector512.ConditionalSelect(IsNegative(x), y, x),
-                            Vector512.Max(x, y)),
-                        y),
-                    x);
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
+            {
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    return
+                        Vector512.ConditionalSelect(Vector512.Equals(x, x),
+                            Vector512.ConditionalSelect(Vector512.Equals(y, y),
+                                Vector512.ConditionalSelect(Vector512.Equals(x, y),
+                                    Vector512.ConditionalSelect(IsNegative(x), y, x),
+                                    Vector512.Max(x, y)),
+                                y),
+                            x);
+                }
+
+                return Vector512.Max(x, y);
+            }
         }
 
         /// <summary>Operator to get x or y based on which has the larger MathF.Abs (but NaNs may not be propagated)</summary>
-        private readonly struct MaxMagnitudeOperator : IAggregationOperator
+        internal readonly struct MaxMagnitudeOperator<T> : IAggregationOperator<T>
+            where T : INumberBase<T>
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static float Invoke(float x, float y)
-            {
-                float xMag = MathF.Abs(x), yMag = MathF.Abs(y);
-                return
-                    xMag == yMag ?
-                        (IsNegative(x) ? y : x) :
-                        (xMag > yMag ? x : y);
-            }
+            public static T Invoke(T x, T y) => T.MaxMagnitude(x, y);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y)
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y)
             {
-                Vector128<float> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
-                return
+                Vector128<T> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
+
+                Vector128<T> result =
                     Vector128.ConditionalSelect(Vector128.Equals(xMag, yMag),
                         Vector128.ConditionalSelect(IsNegative(x), y, x),
                         Vector128.ConditionalSelect(Vector128.GreaterThan(xMag, yMag), x, y));
+
+                // Handle minimum signed value that should have the largest magnitude
+                if (typeof(T) == typeof(sbyte) || typeof(T) == typeof(short) || typeof(T) == typeof(int) || typeof(T) == typeof(long) || typeof(T) == typeof(nint))
+                {
+                    Vector128<T> negativeMagnitudeX = Vector128.LessThan(xMag, Vector128<T>.Zero);
+                    Vector128<T> negativeMagnitudeY = Vector128.LessThan(yMag, Vector128<T>.Zero);
+                    result = Vector128.ConditionalSelect(negativeMagnitudeX,
+                        x,
+                        Vector128.ConditionalSelect(negativeMagnitudeY,
+                            y,
+                            result));
+                }
+
+                return result;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y)
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
             {
-                Vector256<float> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
-                return
+                Vector256<T> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
+
+                Vector256<T> result =
                     Vector256.ConditionalSelect(Vector256.Equals(xMag, yMag),
                         Vector256.ConditionalSelect(IsNegative(x), y, x),
                         Vector256.ConditionalSelect(Vector256.GreaterThan(xMag, yMag), x, y));
+
+                // Handle minimum signed value that should have the largest magnitude
+                if (typeof(T) == typeof(sbyte) || typeof(T) == typeof(short) || typeof(T) == typeof(int) || typeof(T) == typeof(long) || typeof(T) == typeof(nint))
+                {
+                    Vector256<T> negativeMagnitudeX = Vector256.LessThan(xMag, Vector256<T>.Zero);
+                    Vector256<T> negativeMagnitudeY = Vector256.LessThan(yMag, Vector256<T>.Zero);
+                    result = Vector256.ConditionalSelect(negativeMagnitudeX,
+                        x,
+                        Vector256.ConditionalSelect(negativeMagnitudeY,
+                            y,
+                            result));
+                }
+
+                return result;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y)
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
             {
-                Vector512<float> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
-                return
+                Vector512<T> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
+
+                Vector512<T> result =
                     Vector512.ConditionalSelect(Vector512.Equals(xMag, yMag),
                         Vector512.ConditionalSelect(IsNegative(x), y, x),
                         Vector512.ConditionalSelect(Vector512.GreaterThan(xMag, yMag), x, y));
+
+                // Handle minimum signed value that should have the largest magnitude
+                if (typeof(T) == typeof(sbyte) || typeof(T) == typeof(short) || typeof(T) == typeof(int) || typeof(T) == typeof(long) || typeof(T) == typeof(nint))
+                {
+                    Vector512<T> negativeMagnitudeX = Vector512.LessThan(xMag, Vector512<T>.Zero);
+                    Vector512<T> negativeMagnitudeY = Vector512.LessThan(yMag, Vector512<T>.Zero);
+                    result = Vector512.ConditionalSelect(negativeMagnitudeX,
+                        x,
+                        Vector512.ConditionalSelect(negativeMagnitudeY,
+                            y,
+                            result));
+                }
+
+                return result;
             }
 
-            public static float Invoke(Vector128<float> x) => HorizontalAggregate<MaxMagnitudeOperator>(x);
-            public static float Invoke(Vector256<float> x) => HorizontalAggregate<MaxMagnitudeOperator>(x);
-            public static float Invoke(Vector512<float> x) => HorizontalAggregate<MaxMagnitudeOperator>(x);
+            public static T Invoke(Vector128<T> x) => HorizontalAggregate<T, MaxMagnitudeOperator<T>>(x);
+            public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MaxMagnitudeOperator<T>>(x);
+            public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MaxMagnitudeOperator<T>>(x);
         }
 
         /// <summary>Operator to get x or y based on which has the larger MathF.Abs</summary>
-        private readonly struct MaxMagnitudePropagateNaNOperator : IBinaryOperator
+        internal readonly struct MaxMagnitudePropagateNaNOperator<T> : IBinaryOperator<T>
+            where T : INumberBase<T>
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static float Invoke(float x, float y) => MathF.MaxMagnitude(x, y);
+            public static T Invoke(T x, T y) => T.MaxMagnitude(x, y);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y)
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y)
             {
-                Vector128<float> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
-                return
-                    Vector128.ConditionalSelect(Vector128.Equals(x, x),
-                        Vector128.ConditionalSelect(Vector128.Equals(y, y),
-                            Vector128.ConditionalSelect(Vector128.Equals(yMag, xMag),
-                                Vector128.ConditionalSelect(IsNegative(x), y, x),
-                                Vector128.ConditionalSelect(Vector128.GreaterThan(yMag, xMag), y, x)),
-                            y),
-                        x);
+                // Handle NaNs
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    Vector128<T> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
+                    return
+                        Vector128.ConditionalSelect(Vector128.Equals(x, x),
+                            Vector128.ConditionalSelect(Vector128.Equals(y, y),
+                                Vector128.ConditionalSelect(Vector128.Equals(yMag, xMag),
+                                    Vector128.ConditionalSelect(IsNegative(x), y, x),
+                                    Vector128.ConditionalSelect(Vector128.GreaterThan(yMag, xMag), y, x)),
+                                y),
+                            x);
+                }
+
+                return MaxMagnitudeOperator<T>.Invoke(x, y);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y)
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
             {
-                Vector256<float> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
-                return
-                    Vector256.ConditionalSelect(Vector256.Equals(x, x),
-                        Vector256.ConditionalSelect(Vector256.Equals(y, y),
-                            Vector256.ConditionalSelect(Vector256.Equals(xMag, yMag),
-                                Vector256.ConditionalSelect(IsNegative(x), y, x),
-                                Vector256.ConditionalSelect(Vector256.GreaterThan(xMag, yMag), x, y)),
-                            y),
-                        x);
+                // Handle NaNs
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    Vector256<T> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
+                    return
+                        Vector256.ConditionalSelect(Vector256.Equals(x, x),
+                            Vector256.ConditionalSelect(Vector256.Equals(y, y),
+                                Vector256.ConditionalSelect(Vector256.Equals(xMag, yMag),
+                                    Vector256.ConditionalSelect(IsNegative(x), y, x),
+                                    Vector256.ConditionalSelect(Vector256.GreaterThan(xMag, yMag), x, y)),
+                                y),
+                            x);
+                }
+
+                return MaxMagnitudeOperator<T>.Invoke(x, y);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y)
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
             {
-                Vector512<float> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
-                return
-                    Vector512.ConditionalSelect(Vector512.Equals(x, x),
+                // Handle NaNs
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    Vector512<T> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
+                    return
+                        Vector512.ConditionalSelect(Vector512.Equals(x, x),
                         Vector512.ConditionalSelect(Vector512.Equals(y, y),
                             Vector512.ConditionalSelect(Vector512.Equals(xMag, yMag),
                                 Vector512.ConditionalSelect(IsNegative(x), y, x),
                                 Vector512.ConditionalSelect(Vector512.GreaterThan(xMag, yMag), x, y)),
                             y),
                         x);
+                }
+
+                return MaxMagnitudeOperator<T>.Invoke(x, y);
             }
         }
 
-        /// <summary>MathF.Min(x, y) (but NaNs may not be propagated)</summary>
-        private readonly struct MinOperator : IAggregationOperator
+        /// <summary>T.Min(x, y) (but NaNs may not be propagated)</summary>
+        internal readonly struct MinOperator<T> : IAggregationOperator<T>
+            where T : INumber<T>
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static float Invoke(float x, float y) =>
-                x == y ?
-                    (IsNegative(y) ? y : x) :
-                    (y < x ? y : x);
+            public static T Invoke(T x, T y)
+            {
+                if (typeof(T) == typeof(Half) || typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    return x == y ?
+                        (IsNegative(y) ? y : x) :
+                        (y < x ? y : x);
+                }
+
+                return T.Min(x, y);
+            }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y)
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y)
             {
                 if (AdvSimd.IsSupported)
                 {
-                    return AdvSimd.Min(x, y);
+                    if (typeof(T) == typeof(byte)) return AdvSimd.Min(x.AsByte(), y.AsByte()).As<byte, T>();
+                    if (typeof(T) == typeof(sbyte)) return AdvSimd.Min(x.AsSByte(), y.AsSByte()).As<sbyte, T>();
+                    if (typeof(T) == typeof(short)) return AdvSimd.Min(x.AsInt16(), y.AsInt16()).As<short, T>();
+                    if (typeof(T) == typeof(ushort)) return AdvSimd.Min(x.AsUInt16(), y.AsUInt16()).As<ushort, T>();
+                    if (typeof(T) == typeof(int)) return AdvSimd.Min(x.AsInt32(), y.AsInt32()).As<int, T>();
+                    if (typeof(T) == typeof(uint)) return AdvSimd.Min(x.AsUInt32(), y.AsUInt32()).As<uint, T>();
+                    if (typeof(T) == typeof(float)) return AdvSimd.Min(x.AsSingle(), y.AsSingle()).As<float, T>();
                 }
 
-                return
-                    Vector128.ConditionalSelect(Vector128.Equals(x, y),
-                        Vector128.ConditionalSelect(IsNegative(y), y, x),
-                        Vector128.Min(x, y));
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    return
+                        Vector128.ConditionalSelect(Vector128.Equals(x, y),
+                            Vector128.ConditionalSelect(IsNegative(y), y, x),
+                            Vector128.Min(x, y));
+                }
+
+                return Vector128.Min(x, y);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y) =>
-                Vector256.ConditionalSelect(Vector256.Equals(x, y),
-                    Vector256.ConditionalSelect(IsNegative(y), y, x),
-                    Vector256.Min(x, y));
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
+            {
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    return Vector256.ConditionalSelect(Vector256.Equals(x, y),
+                        Vector256.ConditionalSelect(IsNegative(y), y, x),
+                        Vector256.Min(x, y));
+                }
+
+                return Vector256.Min(x, y);
+            }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y) =>
-                Vector512.ConditionalSelect(Vector512.Equals(x, y),
-                    Vector512.ConditionalSelect(IsNegative(y), y, x),
-                    Vector512.Min(x, y));
-
-            public static float Invoke(Vector128<float> x) => HorizontalAggregate<MinOperator>(x);
-            public static float Invoke(Vector256<float> x) => HorizontalAggregate<MinOperator>(x);
-            public static float Invoke(Vector512<float> x) => HorizontalAggregate<MinOperator>(x);
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
+            {
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    return Vector512.ConditionalSelect(Vector512.Equals(x, y),
+                        Vector512.ConditionalSelect(IsNegative(y), y, x),
+                        Vector512.Min(x, y));
+                }
+
+                return Vector512.Min(x, y);
+            }
+
+            public static T Invoke(Vector128<T> x) => HorizontalAggregate<T, MinOperator<T>>(x);
+            public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MinOperator<T>>(x);
+            public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MinOperator<T>>(x);
         }
 
-        /// <summary>MathF.Min(x, y)</summary>
-        private readonly struct MinPropagateNaNOperator : IBinaryOperator
+        /// <summary>T.Min(x, y)</summary>
+        internal readonly struct MinPropagateNaNOperator<T> : IBinaryOperator<T>
+            where T : INumber<T>
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static float Invoke(float x, float y) => MathF.Min(x, y);
+            public static T Invoke(T x, T y) => T.Min(x, y);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y)
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y)
             {
                 if (AdvSimd.IsSupported)
                 {
-                    return AdvSimd.Min(x, y);
+                    if (typeof(T) == typeof(byte)) return AdvSimd.Min(x.AsByte(), y.AsByte()).As<byte, T>();
+                    if (typeof(T) == typeof(sbyte)) return AdvSimd.Min(x.AsSByte(), y.AsSByte()).As<sbyte, T>();
+                    if (typeof(T) == typeof(short)) return AdvSimd.Min(x.AsInt16(), y.AsInt16()).As<short, T>();
+                    if (typeof(T) == typeof(ushort)) return AdvSimd.Min(x.AsUInt16(), y.AsUInt16()).As<ushort, T>();
+                    if (typeof(T) == typeof(int)) return AdvSimd.Min(x.AsInt32(), y.AsInt32()).As<int, T>();
+                    if (typeof(T) == typeof(uint)) return AdvSimd.Min(x.AsUInt32(), y.AsUInt32()).As<uint, T>();
+                    if (typeof(T) == typeof(float)) return AdvSimd.Min(x.AsSingle(), y.AsSingle()).As<float, T>();
                 }
 
-                return
-                    Vector128.ConditionalSelect(Vector128.Equals(x, x),
-                        Vector128.ConditionalSelect(Vector128.Equals(y, y),
-                            Vector128.ConditionalSelect(Vector128.Equals(x, y),
-                                Vector128.ConditionalSelect(IsNegative(x), x, y),
-                                Vector128.Min(x, y)),
-                            y),
-                        x);
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    return
+                        Vector128.ConditionalSelect(Vector128.Equals(x, x),
+                            Vector128.ConditionalSelect(Vector128.Equals(y, y),
+                                Vector128.ConditionalSelect(Vector128.Equals(x, y),
+                                    Vector128.ConditionalSelect(IsNegative(x), x, y),
+                                    Vector128.Min(x, y)),
+                                y),
+                            x);
+                }
+
+                return Vector128.Min(x, y);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y) =>
-                Vector256.ConditionalSelect(Vector256.Equals(x, x),
-                    Vector256.ConditionalSelect(Vector256.Equals(y, y),
-                        Vector256.ConditionalSelect(Vector256.Equals(x, y),
-                            Vector256.ConditionalSelect(IsNegative(x), x, y),
-                            Vector256.Min(x, y)),
-                        y),
-                    x);
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
+            {
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    return
+                        Vector256.ConditionalSelect(Vector256.Equals(x, x),
+                            Vector256.ConditionalSelect(Vector256.Equals(y, y),
+                                Vector256.ConditionalSelect(Vector256.Equals(x, y),
+                                    Vector256.ConditionalSelect(IsNegative(x), x, y),
+                                    Vector256.Min(x, y)),
+                                y),
+                            x);
+                }
+
+                return Vector256.Min(x, y);
+            }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y) =>
-                Vector512.ConditionalSelect(Vector512.Equals(x, x),
-                    Vector512.ConditionalSelect(Vector512.Equals(y, y),
-                        Vector512.ConditionalSelect(Vector512.Equals(x, y),
-                            Vector512.ConditionalSelect(IsNegative(x), x, y),
-                            Vector512.Min(x, y)),
-                        y),
-                    x);
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
+            {
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    return
+                        Vector512.ConditionalSelect(Vector512.Equals(x, x),
+                            Vector512.ConditionalSelect(Vector512.Equals(y, y),
+                                Vector512.ConditionalSelect(Vector512.Equals(x, y),
+                                    Vector512.ConditionalSelect(IsNegative(x), x, y),
+                                    Vector512.Min(x, y)),
+                                y),
+                            x);
+                }
+
+                return Vector512.Min(x, y);
+            }
         }
 
         /// <summary>Operator to get x or y based on which has the smaller MathF.Abs (but NaNs may not be propagated)</summary>
-        private readonly struct MinMagnitudeOperator : IAggregationOperator
+        internal readonly struct MinMagnitudeOperator<T> : IAggregationOperator<T>
+            where T : INumberBase<T>
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static float Invoke(float x, float y)
-            {
-                float xMag = MathF.Abs(x), yMag = MathF.Abs(y);
-                return xMag == yMag ?
-                    (IsNegative(y) ? y : x) :
-                    (yMag < xMag ? y : x);
-            }
+            public static T Invoke(T x, T y) => T.MinMagnitude(x, y);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y)
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y)
             {
-                Vector128<float> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
-                return
+                Vector128<T> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
+
+                Vector128<T> result =
                     Vector128.ConditionalSelect(Vector128.Equals(yMag, xMag),
                         Vector128.ConditionalSelect(IsNegative(y), y, x),
                         Vector128.ConditionalSelect(Vector128.LessThan(yMag, xMag), y, x));
+
+                if (typeof(T) == typeof(sbyte) || typeof(T) == typeof(short) || typeof(T) == typeof(int) || typeof(T) == typeof(long) || typeof(T) == typeof(nint))
+                {
+                    Vector128<T> negativeMagnitudeX = Vector128.LessThan(xMag, Vector128<T>.Zero);
+                    Vector128<T> negativeMagnitudeY = Vector128.LessThan(yMag, Vector128<T>.Zero);
+                    result = Vector128.ConditionalSelect(negativeMagnitudeX,
+                        y,
+                        Vector128.ConditionalSelect(negativeMagnitudeY,
+                            x,
+                            result));
+                }
+
+                return result;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y)
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
             {
-                Vector256<float> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
-                return
+                Vector256<T> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
+
+                Vector256<T> result =
                     Vector256.ConditionalSelect(Vector256.Equals(yMag, xMag),
                         Vector256.ConditionalSelect(IsNegative(y), y, x),
                         Vector256.ConditionalSelect(Vector256.LessThan(yMag, xMag), y, x));
+
+                if (typeof(T) == typeof(sbyte) || typeof(T) == typeof(short) || typeof(T) == typeof(int) || typeof(T) == typeof(long) || typeof(T) == typeof(nint))
+                {
+                    Vector256<T> negativeMagnitudeX = Vector256.LessThan(xMag, Vector256<T>.Zero);
+                    Vector256<T> negativeMagnitudeY = Vector256.LessThan(yMag, Vector256<T>.Zero);
+                    result = Vector256.ConditionalSelect(negativeMagnitudeX,
+                        y,
+                        Vector256.ConditionalSelect(negativeMagnitudeY,
+                            x,
+                            result));
+                }
+
+                return result;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y)
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
             {
-                Vector512<float> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
-                return
+                Vector512<T> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
+
+                Vector512<T> result =
                     Vector512.ConditionalSelect(Vector512.Equals(yMag, xMag),
                         Vector512.ConditionalSelect(IsNegative(y), y, x),
                         Vector512.ConditionalSelect(Vector512.LessThan(yMag, xMag), y, x));
+
+                if (typeof(T) == typeof(sbyte) || typeof(T) == typeof(short) || typeof(T) == typeof(int) || typeof(T) == typeof(long) || typeof(T) == typeof(nint))
+                {
+                    Vector512<T> negativeMagnitudeX = Vector512.LessThan(xMag, Vector512<T>.Zero);
+                    Vector512<T> negativeMagnitudeY = Vector512.LessThan(yMag, Vector512<T>.Zero);
+                    result = Vector512.ConditionalSelect(negativeMagnitudeX,
+                        y,
+                        Vector512.ConditionalSelect(negativeMagnitudeY,
+                            x,
+                            result));
+                }
+
+                return result;
             }
 
-            public static float Invoke(Vector128<float> x) => HorizontalAggregate<MinMagnitudeOperator>(x);
-            public static float Invoke(Vector256<float> x) => HorizontalAggregate<MinMagnitudeOperator>(x);
-            public static float Invoke(Vector512<float> x) => HorizontalAggregate<MinMagnitudeOperator>(x);
+            public static T Invoke(Vector128<T> x) => HorizontalAggregate<T, MinMagnitudeOperator<T>>(x);
+            public static T Invoke(Vector256<T> x) => HorizontalAggregate<T, MinMagnitudeOperator<T>>(x);
+            public static T Invoke(Vector512<T> x) => HorizontalAggregate<T, MinMagnitudeOperator<T>>(x);
         }
 
         /// <summary>Operator to get x or y based on which has the smaller MathF.Abs</summary>
-        private readonly struct MinMagnitudePropagateNaNOperator : IBinaryOperator
+        internal readonly struct MinMagnitudePropagateNaNOperator<T> : IBinaryOperator<T>
+            where T : INumberBase<T>
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static float Invoke(float x, float y) => MathF.MinMagnitude(x, y);
+            public static T Invoke(T x, T y) => T.MinMagnitude(x, y);
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y)
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y)
             {
-                Vector128<float> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
-                return
-                    Vector128.ConditionalSelect(Vector128.Equals(x, x),
-                        Vector128.ConditionalSelect(Vector128.Equals(y, y),
-                            Vector128.ConditionalSelect(Vector128.Equals(yMag, xMag),
-                                Vector128.ConditionalSelect(IsNegative(x), x, y),
-                                Vector128.ConditionalSelect(Vector128.LessThan(xMag, yMag), x, y)),
-                            y),
-                        x);
+                // Handle NaNs
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    Vector128<T> xMag = Vector128.Abs(x), yMag = Vector128.Abs(y);
+                    return
+                        Vector128.ConditionalSelect(Vector128.Equals(x, x),
+                            Vector128.ConditionalSelect(Vector128.Equals(y, y),
+                                Vector128.ConditionalSelect(Vector128.Equals(yMag, xMag),
+                                    Vector128.ConditionalSelect(IsNegative(x), x, y),
+                                    Vector128.ConditionalSelect(Vector128.LessThan(xMag, yMag), x, y)),
+                                y),
+                            x);
+                }
+
+                return MinMagnitudeOperator<T>.Invoke(x, y);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y)
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y)
             {
-                Vector256<float> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
-                return
-                    Vector256.ConditionalSelect(Vector256.Equals(x, x),
-                        Vector256.ConditionalSelect(Vector256.Equals(y, y),
-                            Vector256.ConditionalSelect(Vector256.Equals(yMag, xMag),
-                                Vector256.ConditionalSelect(IsNegative(x), x, y),
-                                Vector256.ConditionalSelect(Vector256.LessThan(xMag, yMag), x, y)),
-                            y),
-                        x);
+                // Handle NaNs
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    Vector256<T> xMag = Vector256.Abs(x), yMag = Vector256.Abs(y);
+                    return
+                        Vector256.ConditionalSelect(Vector256.Equals(x, x),
+                            Vector256.ConditionalSelect(Vector256.Equals(y, y),
+                                Vector256.ConditionalSelect(Vector256.Equals(yMag, xMag),
+                                    Vector256.ConditionalSelect(IsNegative(x), x, y),
+                                    Vector256.ConditionalSelect(Vector256.LessThan(xMag, yMag), x, y)),
+                                y),
+                            x);
+                }
+
+                return MinMagnitudeOperator<T>.Invoke(x, y);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y)
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y)
             {
-                Vector512<float> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
-                return
-                    Vector512.ConditionalSelect(Vector512.Equals(x, x),
-                        Vector512.ConditionalSelect(Vector512.Equals(y, y),
-                            Vector512.ConditionalSelect(Vector512.Equals(yMag, xMag),
-                                Vector512.ConditionalSelect(IsNegative(x), x, y),
-                                Vector512.ConditionalSelect(Vector512.LessThan(xMag, yMag), x, y)),
-                            y),
-                        x);
+                // Handle NaNs
+                if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
+                {
+                    Vector512<T> xMag = Vector512.Abs(x), yMag = Vector512.Abs(y);
+                    return
+                        Vector512.ConditionalSelect(Vector512.Equals(x, x),
+                            Vector512.ConditionalSelect(Vector512.Equals(y, y),
+                                Vector512.ConditionalSelect(Vector512.Equals(yMag, xMag),
+                                    Vector512.ConditionalSelect(IsNegative(x), x, y),
+                                    Vector512.ConditionalSelect(Vector512.LessThan(xMag, yMag), x, y)),
+                                y),
+                            x);
+                }
+
+                return MinMagnitudeOperator<T>.Invoke(x, y);
             }
         }
 
         /// <summary>-x</summary>
-        private readonly struct NegateOperator : IUnaryOperator
+        internal readonly struct NegateOperator<T> : IUnaryOperator<T> where T : IUnaryNegationOperators<T, T>
         {
-            public static float Invoke(float x) => -x;
-            public static Vector128<float> Invoke(Vector128<float> x) => -x;
-            public static Vector256<float> Invoke(Vector256<float> x) => -x;
-            public static Vector512<float> Invoke(Vector512<float> x) => -x;
+            public static bool Vectorizable => true;
+            public static T Invoke(T x) => -x;
+            public static Vector128<T> Invoke(Vector128<T> x) => -x;
+            public static Vector256<T> Invoke(Vector256<T> x) => -x;
+            public static Vector512<T> Invoke(Vector512<T> x) => -x;
         }
 
         /// <summary>(x + y) * z</summary>
-        private readonly struct AddMultiplyOperator : ITernaryOperator
+        internal readonly struct AddMultiplyOperator<T> : ITernaryOperator<T> where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T>
         {
-            public static float Invoke(float x, float y, float z) => (x + y) * z;
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y, Vector128<float> z) => (x + y) * z;
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y, Vector256<float> z) => (x + y) * z;
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y, Vector512<float> z) => (x + y) * z;
+            public static T Invoke(T x, T y, T z) => (x + y) * z;
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y, Vector128<T> z) => (x + y) * z;
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> z) => (x + y) * z;
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z) => (x + y) * z;
         }
 
         /// <summary>(x * y) + z</summary>
-        private readonly struct MultiplyAddOperator : ITernaryOperator
+        internal readonly struct MultiplyAddOperator<T> : ITernaryOperator<T> where T : IAdditionOperators<T, T, T>, IMultiplyOperators<T, T, T>
         {
-            public static float Invoke(float x, float y, float z) => (x * y) + z;
-            public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y, Vector128<float> z) => (x * y) + z;
-            public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y, Vector256<float> z) => (x * y) + z;
-            public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y, Vector512<float> z) => (x * y) + z;
+            public static T Invoke(T x, T y, T z) => (x * y) + z;
+            public static Vector128<T> Invoke(Vector128<T> x, Vector128<T> y, Vector128<T> z) => (x * y) + z;
+            public static Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> z) => (x * y) + z;
+            public static Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z) => (x * y) + z;
         }
 
         /// <summary>x</summary>
-        private readonly struct IdentityOperator : IUnaryOperator
+        internal readonly struct IdentityOperator<T> : IUnaryOperator<T>
         {
-            public static float Invoke(float x) => x;
-            public static Vector128<float> Invoke(Vector128<float> x) => x;
-            public static Vector256<float> Invoke(Vector256<float> x) => x;
-            public static Vector512<float> Invoke(Vector512<float> x) => x;
+            public static bool Vectorizable => true;
+            public static T Invoke(T x) => x;
+            public static Vector128<T> Invoke(Vector128<T> x) => x;
+            public static Vector256<T> Invoke(Vector256<T> x) => x;
+            public static Vector512<T> Invoke(Vector512<T> x) => x;
         }
 
         /// <summary>x * x</summary>
-        private readonly struct SquaredOperator : IUnaryOperator
+        internal readonly struct SquaredOperator<T> : IUnaryOperator<T> where T : IMultiplyOperators<T, T, T>
         {
-            public static float Invoke(float x) => x * x;
-            public static Vector128<float> Invoke(Vector128<float> x) => x * x;
-            public static Vector256<float> Invoke(Vector256<float> x) => x * x;
-            public static Vector512<float> Invoke(Vector512<float> x) => x * x;
+            public static bool Vectorizable => true;
+            public static T Invoke(T x) => x * x;
+            public static Vector128<T> Invoke(Vector128<T> x) => x * x;
+            public static Vector256<T> Invoke(Vector256<T> x) => x * x;
+            public static Vector512<T> Invoke(Vector512<T> x) => x * x;
         }
 
-        /// <summary>MathF.Abs(x)</summary>
-        private readonly struct AbsoluteOperator : IUnaryOperator
+        /// <summary>T.Abs(x)</summary>
+        internal readonly struct AbsoluteOperator<T> : IUnaryOperator<T> where T : INumberBase<T>
         {
-            public static float Invoke(float x) => MathF.Abs(x);
-            public static Vector128<float> Invoke(Vector128<float> x) => Vector128.Abs(x);
-            public static Vector256<float> Invoke(Vector256<float> x) => Vector256.Abs(x);
-            public static Vector512<float> Invoke(Vector512<float> x) => Vector512.Abs(x);
+            public static bool Vectorizable => true;
+
+            public static T Invoke(T x) => T.Abs(x);
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector128<T> Invoke(Vector128<T> x)
+            {
+                if (typeof(T) == typeof(sbyte) ||
+                    typeof(T) == typeof(short) ||
+                    typeof(T) == typeof(int) ||
+                    typeof(T) == typeof(long) ||
+                    typeof(T) == typeof(nint))
+                {
+                    // Handle signed integers specially, in order to throw if any attempt is made to
+                    // take the absolute value of the minimum value of the type, which doesn't have
+                    // a positive absolute value representation.
+                    Vector128<T> negated = -x;
+                    if (Vector128.Equals(x, negated) != Vector128<T>.Zero)
+                    {
+                        ThrowNegateTwosCompOverflow();
+                    }
+
+                    return Vector128.ConditionalSelect(Vector128.LessThan(x, Vector128<T>.Zero), negated, x);
+                }
+
+                return Vector128.Abs(x);
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector256<T> Invoke(Vector256<T> x)
+            {
+                if (typeof(T) == typeof(sbyte) ||
+                    typeof(T) == typeof(short) ||
+                    typeof(T) == typeof(int) ||
+                    typeof(T) == typeof(long) ||
+                    typeof(T) == typeof(nint))
+                {
+                    // Handle signed integers specially, in order to throw if any attempt is made to
+                    // take the absolute value of the minimum value of the type, which doesn't have
+                    // a positive absolute value representation.
+                    Vector256<T> negated = -x;
+                    if (Vector256.Equals(x, negated) != Vector256<T>.Zero)
+                    {
+                        ThrowNegateTwosCompOverflow();
+                    }
+
+                    return Vector256.ConditionalSelect(Vector256.LessThan(x, Vector256<T>.Zero), negated, x);
+                }
+
+                return Vector256.Abs(x);
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static Vector512<T> Invoke(Vector512<T> x)
+            {
+                if (typeof(T) == typeof(sbyte) ||
+                    typeof(T) == typeof(short) ||
+                    typeof(T) == typeof(int) ||
+                    typeof(T) == typeof(long) ||
+                    typeof(T) == typeof(nint))
+                {
+                    // Handle signed integers specially, in order to throw if any attempt is made to
+                    // take the absolute value of the minimum value of the type, which doesn't have
+                    // a positive absolute value representation.
+                    Vector512<T> negated = -x;
+                    if (Vector512.Equals(x, negated) != Vector512<T>.Zero)
+                    {
+                        ThrowNegateTwosCompOverflow();
+                    }
+
+                    return Vector512.ConditionalSelect(Vector512.LessThan(x, Vector512<T>.Zero), negated, x);
+                }
+
+                return Vector512.Abs(x);
+            }
         }
 
-        /// <summary>MathF.Exp(x)</summary>
-        private readonly struct ExpOperator : IUnaryOperator
+        /// <summary>T.Exp(x)</summary>
+        internal readonly struct ExpOperator<T> : IUnaryOperator<T>
+            where T : IExponentialFunctions<T>
         {
             // This code is based on `vrs4_expf` from amd/aocl-libm-ose
             // Copyright (C) 2019-2022 Advanced Micro Devices, Inc. All rights reserved.
@@ -10398,10 +11056,15 @@ public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y)
             private const double C5 = 0.009676036358193323;
             private const double C6 = 0.001341000536524434;
 
-            public static float Invoke(float x) => MathF.Exp(x);
+            public static bool Vectorizable => typeof(T) == typeof(float);
 
-            public static Vector128<float> Invoke(Vector128<float> x)
+            public static T Invoke(T x) => T.Exp(x);
+
+            public static Vector128<T> Invoke(Vector128<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector128<float> x = t.AsSingle();
+
                 // Convert x to double precision
                 (Vector128<double> xl, Vector128<double> xu) = Vector128.Widen(x);
 
@@ -10473,11 +11136,14 @@ public static Vector128<float> Invoke(Vector128<float> x)
                     ret = Vector128.AndNot(ret, Vector128.LessThan(x, Vector128.Create(V_EXPF_MIN)));
                 }
 
-                return ret;
+                return ret.As<float, T>();
             }
 
-            public static Vector256<float> Invoke(Vector256<float> x)
+            public static Vector256<T> Invoke(Vector256<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector256<float> x = t.AsSingle();
+
                 // Convert x to double precision
                 (Vector256<double> xl, Vector256<double> xu) = Vector256.Widen(x);
 
@@ -10549,11 +11215,14 @@ public static Vector256<float> Invoke(Vector256<float> x)
                     ret = Vector256.AndNot(ret, Vector256.LessThan(x, Vector256.Create(V_EXPF_MIN)));
                 }
 
-                return ret;
+                return ret.As<float, T>();
             }
 
-            public static Vector512<float> Invoke(Vector512<float> x)
+            public static Vector512<T> Invoke(Vector512<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector512<float> x = t.AsSingle();
+
                 // Convert x to double precision
                 (Vector512<double> xl, Vector512<double> xu) = Vector512.Widen(x);
 
@@ -10625,12 +11294,13 @@ public static Vector512<float> Invoke(Vector512<float> x)
                     ret = Vector512.AndNot(ret, Vector512.LessThan(x, Vector512.Create(V_EXPF_MIN)));
                 }
 
-                return ret;
+                return ret.As<float, T>();
             }
         }
 
-        /// <summary>MathF.Cosh(x)</summary>
-        private readonly struct CoshOperator : IUnaryOperator
+        /// <summary>T.Cosh(x)</summary>
+        internal readonly struct CoshOperator<T> : IUnaryOperator<T>
+            where T : IHyperbolicFunctions<T>
         {
             // This code is based on `vrs4_coshf` from amd/aocl-libm-ose
             // Copyright (C) 2008-2022 Advanced Micro Devices, Inc. All rights reserved.
@@ -10657,32 +11327,44 @@ public static Vector512<float> Invoke(Vector512<float> x)
             private const float HALFV = 1.0000138f;
             private const float INVV2 = 0.24999309f;
 
-            public static float Invoke(float x) => MathF.Cosh(x);
+            public static bool Vectorizable => typeof(T) == typeof(float);
+
+            public static T Invoke(T x) => T.Cosh(x);
 
-            public static Vector128<float> Invoke(Vector128<float> x)
+            public static Vector128<T> Invoke(Vector128<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector128<float> x = t.AsSingle();
+
                 Vector128<float> y = Vector128.Abs(x);
-                Vector128<float> z = ExpOperator.Invoke(y - Vector128.Create(LOGV));
-                return Vector128.Create(HALFV) * (z + (Vector128.Create(INVV2) / z));
+                Vector128<float> z = ExpOperator<float>.Invoke(y - Vector128.Create(LOGV));
+                return (Vector128.Create(HALFV) * (z + (Vector128.Create(INVV2) / z))).As<float, T>();
             }
 
-            public static Vector256<float> Invoke(Vector256<float> x)
+            public static Vector256<T> Invoke(Vector256<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector256<float> x = t.AsSingle();
+
                 Vector256<float> y = Vector256.Abs(x);
-                Vector256<float> z = ExpOperator.Invoke(y - Vector256.Create(LOGV));
-                return Vector256.Create(HALFV) * (z + (Vector256.Create(INVV2) / z));
+                Vector256<float> z = ExpOperator<float>.Invoke(y - Vector256.Create(LOGV));
+                return (Vector256.Create(HALFV) * (z + (Vector256.Create(INVV2) / z))).As<float, T>();
             }
 
-            public static Vector512<float> Invoke(Vector512<float> x)
+            public static Vector512<T> Invoke(Vector512<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector512<float> x = t.AsSingle();
+
                 Vector512<float> y = Vector512.Abs(x);
-                Vector512<float> z = ExpOperator.Invoke(y - Vector512.Create(LOGV));
-                return Vector512.Create(HALFV) * (z + (Vector512.Create(INVV2) / z));
+                Vector512<float> z = ExpOperator<float>.Invoke(y - Vector512.Create(LOGV));
+                return (Vector512.Create(HALFV) * (z + (Vector512.Create(INVV2) / z))).As<float, T>();
             }
         }
 
-        /// <summary>MathF.Sinh(x)</summary>
-        private readonly struct SinhOperator : IUnaryOperator
+        /// <summary>T.Sinh(x)</summary>
+        internal readonly struct SinhOperator<T> : IUnaryOperator<T>
+            where T : IHyperbolicFunctions<T>
         {
             // Same as cosh, but with `z -` rather than `z +`, and with the sign
             // flipped on the result based on the sign of the input.
@@ -10692,38 +11374,50 @@ public static Vector512<float> Invoke(Vector512<float> x)
             private const float HALFV = 1.0000138f;
             private const float INVV2 = 0.24999309f;
 
-            public static float Invoke(float x) => MathF.Sinh(x);
+            public static bool Vectorizable => typeof(T) == typeof(float);
+
+            public static T Invoke(T x) => T.Sinh(x);
 
-            public static Vector128<float> Invoke(Vector128<float> x)
+            public static Vector128<T> Invoke(Vector128<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector128<float> x = t.AsSingle();
+
                 Vector128<float> y = Vector128.Abs(x);
-                Vector128<float> z = ExpOperator.Invoke(y - Vector128.Create(LOGV));
+                Vector128<float> z = ExpOperator<float>.Invoke(y - Vector128.Create(LOGV));
                 Vector128<float> result = Vector128.Create(HALFV) * (z - (Vector128.Create(INVV2) / z));
                 Vector128<uint> sign = x.AsUInt32() & Vector128.Create(~SIGN_MASK);
-                return (sign ^ result.AsUInt32()).AsSingle();
+                return (sign ^ result.AsUInt32()).AsSingle().As<float, T>();
             }
 
-            public static Vector256<float> Invoke(Vector256<float> x)
+            public static Vector256<T> Invoke(Vector256<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector256<float> x = t.AsSingle();
+
                 Vector256<float> y = Vector256.Abs(x);
-                Vector256<float> z = ExpOperator.Invoke(y - Vector256.Create(LOGV));
+                Vector256<float> z = ExpOperator<float>.Invoke(y - Vector256.Create(LOGV));
                 Vector256<float> result = Vector256.Create(HALFV) * (z - (Vector256.Create(INVV2) / z));
                 Vector256<uint> sign = x.AsUInt32() & Vector256.Create(~SIGN_MASK);
-                return (sign ^ result.AsUInt32()).AsSingle();
+                return (sign ^ result.AsUInt32()).AsSingle().As<float, T>();
             }
 
-            public static Vector512<float> Invoke(Vector512<float> x)
+            public static Vector512<T> Invoke(Vector512<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector512<float> x = t.AsSingle();
+
                 Vector512<float> y = Vector512.Abs(x);
-                Vector512<float> z = ExpOperator.Invoke(y - Vector512.Create(LOGV));
+                Vector512<float> z = ExpOperator<float>.Invoke(y - Vector512.Create(LOGV));
                 Vector512<float> result = Vector512.Create(HALFV) * (z - (Vector512.Create(INVV2) / z));
                 Vector512<uint> sign = x.AsUInt32() & Vector512.Create(~SIGN_MASK);
-                return (sign ^ result.AsUInt32()).AsSingle();
+                return (sign ^ result.AsUInt32()).AsSingle().As<float, T>();
             }
         }
 
-        /// <summary>MathF.Tanh(x)</summary>
-        private readonly struct TanhOperator : IUnaryOperator
+        /// <summary>T.Tanh(x)</summary>
+        internal readonly struct TanhOperator<T> : IUnaryOperator<T>
+            where T : IHyperbolicFunctions<T>
         {
             // This code is based on `vrs4_tanhf` from amd/aocl-libm-ose
             // Copyright (C) 2008-2022 Advanced Micro Devices, Inc. All rights reserved.
@@ -10746,35 +11440,47 @@ public static Vector512<float> Invoke(Vector512<float> x)
 
             private const uint SIGN_MASK = 0x7FFFFFFF;
 
-            public static float Invoke(float x) => MathF.Tanh(x);
+            public static bool Vectorizable => typeof(T) == typeof(float);
 
-            public static Vector128<float> Invoke(Vector128<float> x)
+            public static T Invoke(T x) => T.Tanh(x);
+
+            public static Vector128<T> Invoke(Vector128<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector128<float> x = t.AsSingle();
+
                 Vector128<float> y = Vector128.Abs(x);
-                Vector128<float> z = ExpOperator.Invoke(Vector128.Create(-2f) * y) - Vector128.Create(1f);
+                Vector128<float> z = ExpOperator<float>.Invoke(Vector128.Create(-2f) * y) - Vector128.Create(1f);
                 Vector128<uint> sign = x.AsUInt32() & Vector128.Create(~SIGN_MASK);
-                return (sign ^ (-z / (z + Vector128.Create(2f))).AsUInt32()).AsSingle();
+                return (sign ^ (-z / (z + Vector128.Create(2f))).AsUInt32()).AsSingle().As<float, T>();
             }
 
-            public static Vector256<float> Invoke(Vector256<float> x)
+            public static Vector256<T> Invoke(Vector256<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector256<float> x = t.AsSingle();
+
                 Vector256<float> y = Vector256.Abs(x);
-                Vector256<float> z = ExpOperator.Invoke(Vector256.Create(-2f) * y) - Vector256.Create(1f);
+                Vector256<float> z = ExpOperator<float>.Invoke(Vector256.Create(-2f) * y) - Vector256.Create(1f);
                 Vector256<uint> sign = x.AsUInt32() & Vector256.Create(~SIGN_MASK);
-                return (sign ^ (-z / (z + Vector256.Create(2f))).AsUInt32()).AsSingle();
+                return (sign ^ (-z / (z + Vector256.Create(2f))).AsUInt32()).AsSingle().As<float, T>();
             }
 
-            public static Vector512<float> Invoke(Vector512<float> x)
+            public static Vector512<T> Invoke(Vector512<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector512<float> x = t.AsSingle();
+
                 Vector512<float> y = Vector512.Abs(x);
-                Vector512<float> z = ExpOperator.Invoke(Vector512.Create(-2f) * y) - Vector512.Create(1f);
+                Vector512<float> z = ExpOperator<float>.Invoke(Vector512.Create(-2f) * y) - Vector512.Create(1f);
                 Vector512<uint> sign = x.AsUInt32() & Vector512.Create(~SIGN_MASK);
-                return (sign ^ (-z / (z + Vector512.Create(2f))).AsUInt32()).AsSingle();
+                return (sign ^ (-z / (z + Vector512.Create(2f))).AsUInt32()).AsSingle().As<float, T>();
             }
         }
 
-        /// <summary>MathF.Log(x)</summary>
-        private readonly struct LogOperator : IUnaryOperator
+        /// <summary>T.Log(x)</summary>
+        internal readonly struct LogOperator<T> : IUnaryOperator<T>
+            where T : ILogarithmicFunctions<T>
         {
             // This code is based on `vrs4_logf` from amd/aocl-libm-ose
             // Copyright (C) 2018-2019 Advanced Micro Devices, Inc. All rights reserved.
@@ -10847,10 +11553,15 @@ public static Vector512<float> Invoke(Vector512<float> x)
             private const float C9 = 0.14401625f;
             private const float C10 = -0.13657966f;
 
-            public static float Invoke(float x) => MathF.Log(x);
+            public static bool Vectorizable => typeof(T) == typeof(float);
+
+            public static T Invoke(T x) => T.Log(x);
 
-            public static Vector128<float> Invoke(Vector128<float> x)
+            public static Vector128<T> Invoke(Vector128<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector128<float> x = t.AsSingle();
+
                 Vector128<float> specialResult = x;
 
                 // x is subnormal or infinity or NaN
@@ -10915,11 +11626,14 @@ public static Vector128<float> Invoke(Vector128<float> x)
                     specialMask.AsSingle(),
                     specialResult,
                     n * Vector128.Create(V_LN2) + q
-                );
+                ).As<float, T>();
             }
 
-            public static Vector256<float> Invoke(Vector256<float> x)
+            public static Vector256<T> Invoke(Vector256<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector256<float> x = t.AsSingle();
+
                 Vector256<float> specialResult = x;
 
                 // x is subnormal or infinity or NaN
@@ -10984,11 +11698,14 @@ public static Vector256<float> Invoke(Vector256<float> x)
                     specialMask.AsSingle(),
                     specialResult,
                     n * Vector256.Create(V_LN2) + q
-                );
+                ).As<float, T>();
             }
 
-            public static Vector512<float> Invoke(Vector512<float> x)
+            public static Vector512<T> Invoke(Vector512<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector512<float> x = t.AsSingle();
+
                 Vector512<float> specialResult = x;
 
                 // x is subnormal or infinity or NaN
@@ -11053,12 +11770,13 @@ public static Vector512<float> Invoke(Vector512<float> x)
                     specialMask.AsSingle(),
                     specialResult,
                     n * Vector512.Create(V_LN2) + q
-                );
+                ).As<float, T>();
             }
         }
 
-        /// <summary>MathF.Log2(x)</summary>
-        private readonly struct Log2Operator : IUnaryOperator
+        /// <summary>T.Log2(x)</summary>
+        internal readonly struct Log2Operator<T> : IUnaryOperator<T>
+            where T : ILogarithmicFunctions<T>
         {
             // This code is based on `vrs4_log2f` from amd/aocl-libm-ose
             // Copyright (C) 2021-2022 Advanced Micro Devices, Inc. All rights reserved.
@@ -11126,10 +11844,15 @@ public static Vector512<float> Invoke(Vector512<float> x)
             private const float C8 = -0.22616665f;
             private const float C9 = 0.21228963f;
 
-            public static float Invoke(float x) => MathF.Log2(x);
+            public static bool Vectorizable => typeof(T) == typeof(float);
+
+            public static T Invoke(T x) => T.Log2(x);
 
-            public static Vector128<float> Invoke(Vector128<float> x)
+            public static Vector128<T> Invoke(Vector128<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector128<float> x = t.AsSingle();
+
                 Vector128<float> specialResult = x;
 
                 // x is subnormal or infinity or NaN
@@ -11194,11 +11917,14 @@ public static Vector128<float> Invoke(Vector128<float> x)
                     specialMask.AsSingle(),
                     specialResult,
                     n + poly
-                );
+                ).As<float, T>();
             }
 
-            public static Vector256<float> Invoke(Vector256<float> x)
+            public static Vector256<T> Invoke(Vector256<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector256<float> x = t.AsSingle();
+
                 Vector256<float> specialResult = x;
 
                 // x is subnormal or infinity or NaN
@@ -11263,11 +11989,14 @@ public static Vector256<float> Invoke(Vector256<float> x)
                     specialMask.AsSingle(),
                     specialResult,
                     n + poly
-                );
+                ).As<float, T>();
             }
 
-            public static Vector512<float> Invoke(Vector512<float> x)
+            public static Vector512<T> Invoke(Vector512<T> t)
             {
+                Debug.Assert(typeof(T) == typeof(float));
+                Vector512<float> x = t.AsSingle();
+
                 Vector512<float> specialResult = x;
 
                 // x is subnormal or infinity or NaN
@@ -11332,108 +12061,112 @@ public static Vector512<float> Invoke(Vector512<float> x)
                     specialMask.AsSingle(),
                     specialResult,
                     n + poly
-                );
+                ).As<float, T>();
             }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector128<float> ElementWiseSelect(Vector128<float> mask, Vector128<float> left, Vector128<float> right)
-        {
-            if (Sse41.IsSupported)
-                return Sse41.BlendVariable(left, right, ~mask);
-
-            return Vector128.ConditionalSelect(mask, left, right);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector128<int> ElementWiseSelect(Vector128<int> mask, Vector128<int> left, Vector128<int> right)
+        private static Vector128<T> ElementWiseSelect<T>(Vector128<T> mask, Vector128<T> left, Vector128<T> right)
         {
             if (Sse41.IsSupported)
-                return Sse41.BlendVariable(left, right, ~mask);
+            {
+                if (typeof(T) == typeof(byte)) return Sse41.BlendVariable(left.AsByte(), right.AsByte(), (~mask).AsByte()).As<byte, T>();
+                if (typeof(T) == typeof(sbyte)) return Sse41.BlendVariable(left.AsSByte(), right.AsSByte(), (~mask).AsSByte()).As<sbyte, T>();
+                if (typeof(T) == typeof(ushort)) return Sse41.BlendVariable(left.AsUInt16(), right.AsUInt16(), (~mask).AsUInt16()).As<ushort, T>();
+                if (typeof(T) == typeof(short)) return Sse41.BlendVariable(left.AsInt16(), right.AsInt16(), (~mask).AsInt16()).As<short, T>();
+                if (typeof(T) == typeof(uint)) return Sse41.BlendVariable(left.AsUInt32(), right.AsUInt32(), (~mask).AsUInt32()).As<uint, T>();
+                if (typeof(T) == typeof(int)) return Sse41.BlendVariable(left.AsInt32(), right.AsInt32(), (~mask).AsInt32()).As<int, T>();
+                if (typeof(T) == typeof(ulong)) return Sse41.BlendVariable(left.AsUInt64(), right.AsUInt64(), (~mask).AsUInt64()).As<ulong, T>();
+                if (typeof(T) == typeof(long)) return Sse41.BlendVariable(left.AsInt64(), right.AsInt64(), (~mask).AsInt64()).As<long, T>();
+                if (typeof(T) == typeof(float)) return Sse41.BlendVariable(left.AsSingle(), right.AsSingle(), (~mask).AsSingle()).As<float, T>();
+                if (typeof(T) == typeof(double)) return Sse41.BlendVariable(left.AsDouble(), right.AsDouble(), (~mask).AsDouble()).As<double, T>();
+            }
 
             return Vector128.ConditionalSelect(mask, left, right);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector256<float> ElementWiseSelect(Vector256<float> mask, Vector256<float> left, Vector256<float> right)
-        {
-            if (Avx2.IsSupported)
-                return Avx2.BlendVariable(left, right, ~mask);
-
-            return Vector256.ConditionalSelect(mask, left, right);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector256<int> ElementWiseSelect(Vector256<int> mask, Vector256<int> left, Vector256<int> right)
+        private static Vector256<T> ElementWiseSelect<T>(Vector256<T> mask, Vector256<T> left, Vector256<T> right)
         {
             if (Avx2.IsSupported)
-                return Avx2.BlendVariable(left, right, ~mask);
+            {
+                if (typeof(T) == typeof(byte)) return Avx2.BlendVariable(left.AsByte(), right.AsByte(), (~mask).AsByte()).As<byte, T>();
+                if (typeof(T) == typeof(sbyte)) return Avx2.BlendVariable(left.AsSByte(), right.AsSByte(), (~mask).AsSByte()).As<sbyte, T>();
+                if (typeof(T) == typeof(ushort)) return Avx2.BlendVariable(left.AsUInt16(), right.AsUInt16(), (~mask).AsUInt16()).As<ushort, T>();
+                if (typeof(T) == typeof(short)) return Avx2.BlendVariable(left.AsInt16(), right.AsInt16(), (~mask).AsInt16()).As<short, T>();
+                if (typeof(T) == typeof(uint)) return Avx2.BlendVariable(left.AsUInt32(), right.AsUInt32(), (~mask).AsUInt32()).As<uint, T>();
+                if (typeof(T) == typeof(int)) return Avx2.BlendVariable(left.AsInt32(), right.AsInt32(), (~mask).AsInt32()).As<int, T>();
+                if (typeof(T) == typeof(ulong)) return Avx2.BlendVariable(left.AsUInt64(), right.AsUInt64(), (~mask).AsUInt64()).As<ulong, T>();
+                if (typeof(T) == typeof(long)) return Avx2.BlendVariable(left.AsInt64(), right.AsInt64(), (~mask).AsInt64()).As<long, T>();
+                if (typeof(T) == typeof(float)) return Avx2.BlendVariable(left.AsSingle(), right.AsSingle(), (~mask).AsSingle()).As<float, T>();
+                if (typeof(T) == typeof(double)) return Avx2.BlendVariable(left.AsDouble(), right.AsDouble(), (~mask).AsDouble()).As<double, T>();
+            }
 
             return Vector256.ConditionalSelect(mask, left, right);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector512<float> ElementWiseSelect(Vector512<float> mask, Vector512<float> left, Vector512<float> right)
-        {
-            if (Avx512F.IsSupported)
-                return Avx512F.BlendVariable(left, right, ~mask);
-
-            return Vector512.ConditionalSelect(mask, left, right);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static Vector512<int> ElementWiseSelect(Vector512<int> mask, Vector512<int> left, Vector512<int> right)
+        private static Vector512<T> ElementWiseSelect<T>(Vector512<T> mask, Vector512<T> left, Vector512<T> right)
         {
             if (Avx512F.IsSupported)
-                return Avx512F.BlendVariable(left, right, ~mask);
+            {
+                if (typeof(T) == typeof(uint)) return Avx512F.BlendVariable(left.AsUInt32(), right.AsUInt32(), (~mask).AsUInt32()).As<uint, T>();
+                if (typeof(T) == typeof(int)) return Avx512F.BlendVariable(left.AsInt32(), right.AsInt32(), (~mask).AsInt32()).As<int, T>();
+                if (typeof(T) == typeof(ulong)) return Avx512F.BlendVariable(left.AsUInt64(), right.AsUInt64(), (~mask).AsUInt64()).As<ulong, T>();
+                if (typeof(T) == typeof(long)) return Avx512F.BlendVariable(left.AsInt64(), right.AsInt64(), (~mask).AsInt64()).As<long, T>();
+                if (typeof(T) == typeof(float)) return Avx512F.BlendVariable(left.AsSingle(), right.AsSingle(), (~mask).AsSingle()).As<float, T>();
+                if (typeof(T) == typeof(double)) return Avx512F.BlendVariable(left.AsDouble(), right.AsDouble(), (~mask).AsDouble()).As<double, T>();
+            }
 
             return Vector512.ConditionalSelect(mask, left, right);
         }
 
         /// <summary>1f / (1f + MathF.Exp(-x))</summary>
-        private readonly struct SigmoidOperator : IUnaryOperator
+        internal readonly struct SigmoidOperator<T> : IUnaryOperator<T> where T : IExponentialFunctions<T>
         {
-            public static float Invoke(float x) => 1.0f / (1.0f + MathF.Exp(-x));
-            public static Vector128<float> Invoke(Vector128<float> x) => Vector128.Create(1f) / (Vector128.Create(1f) + ExpOperator.Invoke(-x));
-            public static Vector256<float> Invoke(Vector256<float> x) => Vector256.Create(1f) / (Vector256.Create(1f) + ExpOperator.Invoke(-x));
-            public static Vector512<float> Invoke(Vector512<float> x) => Vector512.Create(1f) / (Vector512.Create(1f) + ExpOperator.Invoke(-x));
+            public static bool Vectorizable => typeof(T) == typeof(float);
+            public static T Invoke(T x) => T.One / (T.One + T.Exp(-x));
+            public static Vector128<T> Invoke(Vector128<T> x) => Vector128.Create(T.One) / (Vector128.Create(T.One) + ExpOperator<T>.Invoke(-x));
+            public static Vector256<T> Invoke(Vector256<T> x) => Vector256.Create(T.One) / (Vector256.Create(T.One) + ExpOperator<T>.Invoke(-x));
+            public static Vector512<T> Invoke(Vector512<T> x) => Vector512.Create(T.One) / (Vector512.Create(T.One) + ExpOperator<T>.Invoke(-x));
         }
 
         /// <summary>Operator that takes one input value and returns a single value.</summary>
-        private interface IUnaryOperator
+        private interface IUnaryOperator<T>
         {
-            static abstract float Invoke(float x);
-            static abstract Vector128<float> Invoke(Vector128<float> x);
-            static abstract Vector256<float> Invoke(Vector256<float> x);
-            static abstract Vector512<float> Invoke(Vector512<float> x);
+            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);
         }
 
         /// <summary>Operator that takes two input values and returns a single value.</summary>
-        private interface IBinaryOperator
+        private interface IBinaryOperator<T>
         {
-            static abstract float Invoke(float x, float y);
-            static abstract Vector128<float> Invoke(Vector128<float> x, Vector128<float> y);
-            static abstract Vector256<float> Invoke(Vector256<float> x, Vector256<float> y);
-            static abstract Vector512<float> Invoke(Vector512<float> x, Vector512<float> y);
+            static abstract T Invoke(T x, T y);
+            static abstract Vector128<T> Invoke(Vector128<T> x, Vector128<T> y);
+            static abstract Vector256<T> Invoke(Vector256<T> x, Vector256<T> y);
+            static abstract Vector512<T> Invoke(Vector512<T> x, Vector512<T> y);
         }
 
-        /// <summary><see cref="IBinaryOperator"/> that specializes horizontal aggregation of all elements in a vector.</summary>
-        private interface IAggregationOperator : IBinaryOperator
+        /// <summary><see cref="IBinaryOperator{T}"/> that specializes horizontal aggregation of all elements in a vector.</summary>
+        private interface IAggregationOperator<T> : IBinaryOperator<T>
         {
-            static abstract float Invoke(Vector128<float> x);
-            static abstract float Invoke(Vector256<float> x);
-            static abstract float Invoke(Vector512<float> x);
+            static abstract T Invoke(Vector128<T> x);
+            static abstract T Invoke(Vector256<T> x);
+            static abstract T Invoke(Vector512<T> x);
 
-            static virtual float IdentityValue => throw new NotSupportedException();
+            static virtual T IdentityValue => throw new NotSupportedException();
         }
 
         /// <summary>Operator that takes three input values and returns a single value.</summary>
-        private interface ITernaryOperator
+        private interface ITernaryOperator<T>
         {
-            static abstract float Invoke(float x, float y, float z);
-            static abstract Vector128<float> Invoke(Vector128<float> x, Vector128<float> y, Vector128<float> z);
-            static abstract Vector256<float> Invoke(Vector256<float> x, Vector256<float> y, Vector256<float> z);
-            static abstract Vector512<float> Invoke(Vector512<float> x, Vector512<float> y, Vector512<float> z);
+            static abstract T Invoke(T x, T y, T z);
+            static abstract Vector128<T> Invoke(Vector128<T> x, Vector128<T> y, Vector128<T> z);
+            static abstract Vector256<T> Invoke(Vector256<T> x, Vector256<T> y, Vector256<T> z);
+            static abstract Vector512<T> Invoke(Vector512<T> x, Vector512<T> y, Vector512<T> z);
         }
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.netstandard.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netstandard/TensorPrimitives.Single.netstandard.cs
similarity index 98%
rename from src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.netstandard.cs
rename to src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netstandard/TensorPrimitives.Single.netstandard.cs
index dcb7a100baac31..fe32027099c7e3 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.netstandard.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netstandard/TensorPrimitives.Single.netstandard.cs
@@ -1507,7 +1507,7 @@ static void VectorizedSmall(ref float xRef, ref float yRef, ref float dRef, nuin
         private static void InvokeSpanScalarIntoSpan<TBinaryOperator>(
             ReadOnlySpan<float> x, float y, Span<float> destination, TBinaryOperator op = default)
             where TBinaryOperator : struct, IBinaryOperator =>
-            InvokeSpanScalarIntoSpan<IdentityOperator, TBinaryOperator>(x, y, destination, default, op);
+            InvokeSpanScalarIntoSpan<IdentityOperator_Single, TBinaryOperator>(x, y, destination, default, op);
 
         /// <summary>
         /// Performs an element-wise operation on <paramref name="x"/> and <paramref name="y"/>,
@@ -2901,7 +2901,7 @@ private static Vector<float> CreateAlignmentMaskSingleVector(int count)
             Debug.Assert(Vector<float>.Count is 4 or 8 or 16);
 
             return AsVector(
-                ref Unsafe.As<uint, float>(ref MemoryMarshal.GetReference(AlignmentUInt32Mask_16x16)),
+                ref Unsafe.As<uint, float>(ref MemoryMarshal.GetReference(AlignmentUInt32Mask_16x17)),
                 (count * 16));
         }
 
@@ -2914,12 +2914,12 @@ private static Vector<float> CreateRemainderMaskSingleVector(int count)
             Debug.Assert(Vector<float>.Count is 4 or 8 or 16);
 
             return AsVector(
-                ref Unsafe.As<uint, float>(ref MemoryMarshal.GetReference(RemainderUInt32Mask_16x16)),
+                ref Unsafe.As<uint, float>(ref MemoryMarshal.GetReference(RemainderUInt32Mask_16x17)),
                 (count * 16) + (16 - Vector<float>.Count));
         }
 
         /// <summary>x + y</summary>
-        private readonly struct AddOperator : IAggregationOperator
+        private readonly struct AddOperator_Single : IAggregationOperator
         {
             public float Invoke(float x, float y) => x + y;
             public Vector<float> Invoke(Vector<float> x, Vector<float> y) => x + y;
@@ -2927,14 +2927,14 @@ ref Unsafe.As<uint, float>(ref MemoryMarshal.GetReference(RemainderUInt32Mask_16
         }
 
         /// <summary>x - y</summary>
-        private readonly struct SubtractOperator : IBinaryOperator
+        private readonly struct SubtractOperator_Single : IBinaryOperator
         {
             public float Invoke(float x, float y) => x - y;
             public Vector<float> Invoke(Vector<float> x, Vector<float> y) => x - y;
         }
 
         /// <summary>(x - y) * (x - y)</summary>
-        private readonly struct SubtractSquaredOperator : IBinaryOperator
+        private readonly struct SubtractSquaredOperator_Single : IBinaryOperator
         {
             public float Invoke(float x, float y)
             {
@@ -2950,7 +2950,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y)
         }
 
         /// <summary>x * y</summary>
-        private readonly struct MultiplyOperator : IAggregationOperator
+        private readonly struct MultiplyOperator_Single : IAggregationOperator
         {
             public float Invoke(float x, float y) => x * y;
             public Vector<float> Invoke(Vector<float> x, Vector<float> y) => x * y;
@@ -2958,7 +2958,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y)
         }
 
         /// <summary>x / y</summary>
-        private readonly struct DivideOperator : IBinaryOperator
+        private readonly struct DivideOperator_Single : IBinaryOperator
         {
             public float Invoke(float x, float y) => x / y;
             public Vector<float> Invoke(Vector<float> x, Vector<float> y) => x / y;
@@ -2972,7 +2972,7 @@ private interface IIndexOfOperator
         }
 
         /// <summary>Returns the index of MathF.Max(x, y)</summary>
-        private readonly struct IndexOfMaxOperator : IIndexOfOperator
+        private readonly struct IndexOfMaxOperator_Single : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Invoke(Vector<float> result, Vector<int> resultIndex)
@@ -3037,7 +3037,7 @@ public int Invoke(ref float result, float current, int resultIndex, int curIndex
             }
         }
 
-        private readonly struct IndexOfMaxMagnitudeOperator : IIndexOfOperator
+        private readonly struct IndexOfMaxMagnitudeOperator_Single : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Invoke(ref float result, float current, int resultIndex, int curIndex)
@@ -3107,7 +3107,7 @@ public void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<i
             }
         }
 
-        private readonly struct IndexOfMinOperator : IIndexOfOperator
+        private readonly struct IndexOfMinOperator_Single : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Invoke(ref float result, float current, int resultIndex, int curIndex)
@@ -3172,7 +3172,7 @@ public void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<i
             }
         }
 
-        private readonly struct IndexOfMinMagnitudeOperator : IIndexOfOperator
+        private readonly struct IndexOfMinMagnitudeOperator_Single : IIndexOfOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public int Invoke(ref float result, float current, int resultIndex, int curIndex)
@@ -3242,7 +3242,7 @@ public void Invoke(ref Vector<float> result, Vector<float> current, ref Vector<i
         }
 
         /// <summary>MathF.Max(x, y) (but without guaranteed NaN propagation)</summary>
-        private readonly struct MaxOperator : IBinaryOperator
+        private readonly struct MaxOperator_Single : IBinaryOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public float Invoke(float x, float y) =>
@@ -3258,7 +3258,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y) =>
         }
 
         /// <summary>MathF.Max(x, y)</summary>
-        private readonly struct MaxPropagateNaNOperator : IBinaryOperator
+        private readonly struct MaxPropagateNaNOperator_Single : IBinaryOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public float Invoke(float x, float y) => MathF.Max(x, y);
@@ -3275,7 +3275,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y) =>
         }
 
         /// <summary>Operator to get x or y based on which has the larger MathF.Abs (but NaNs may not be propagated)</summary>
-        private readonly struct MaxMagnitudeOperator : IBinaryOperator
+        private readonly struct MaxMagnitudeOperator_Single : IBinaryOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public float Invoke(float x, float y)
@@ -3299,7 +3299,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y)
         }
 
         /// <summary>Operator to get x or y based on which has the larger MathF.Abs</summary>
-        private readonly struct MaxMagnitudePropagateNaNOperator : IBinaryOperator
+        private readonly struct MaxMagnitudePropagateNaNOperator_Single : IBinaryOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public float Invoke(float x, float y)
@@ -3324,7 +3324,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y)
         }
 
         /// <summary>MathF.Min(x, y) (but NaNs may not be propagated)</summary>
-        private readonly struct MinOperator : IBinaryOperator
+        private readonly struct MinOperator_Single : IBinaryOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public float Invoke(float x, float y) =>
@@ -3340,7 +3340,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y) =>
         }
 
         /// <summary>MathF.Min(x, y)</summary>
-        private readonly struct MinPropagateNaNOperator : IBinaryOperator
+        private readonly struct MinPropagateNaNOperator_Single : IBinaryOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public float Invoke(float x, float y) => MathF.Min(x, y);
@@ -3357,7 +3357,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y) =>
         }
 
         /// <summary>Operator to get x or y based on which has the smaller MathF.Abs (but NaNs may not be propagated)</summary>
-        private readonly struct MinMagnitudeOperator : IBinaryOperator
+        private readonly struct MinMagnitudeOperator_Single : IBinaryOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public float Invoke(float x, float y)
@@ -3381,7 +3381,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y)
         }
 
         /// <summary>Operator to get x or y based on which has the smaller MathF.Abs</summary>
-        private readonly struct MinMagnitudePropagateNaNOperator : IBinaryOperator
+        private readonly struct MinMagnitudePropagateNaNOperator_Single : IBinaryOperator
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public float Invoke(float x, float y)
@@ -3407,7 +3407,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y)
         }
 
         /// <summary>-x</summary>
-        private readonly struct NegateOperator : IUnaryOperator
+        private readonly struct NegateOperator_Single : IUnaryOperator
         {
             public bool CanVectorize => true;
             public float Invoke(float x) => -x;
@@ -3415,21 +3415,21 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y)
         }
 
         /// <summary>(x + y) * z</summary>
-        private readonly struct AddMultiplyOperator : ITernaryOperator
+        private readonly struct AddMultiplyOperator_Single : ITernaryOperator
         {
             public float Invoke(float x, float y, float z) => (x + y) * z;
             public Vector<float> Invoke(Vector<float> x, Vector<float> y, Vector<float> z) => (x + y) * z;
         }
 
         /// <summary>(x * y) + z</summary>
-        private readonly struct MultiplyAddOperator : ITernaryOperator
+        private readonly struct MultiplyAddOperator_Single : ITernaryOperator
         {
             public float Invoke(float x, float y, float z) => (x * y) + z;
             public Vector<float> Invoke(Vector<float> x, Vector<float> y, Vector<float> z) => (x * y) + z;
         }
 
         /// <summary>x</summary>
-        private readonly struct IdentityOperator : IUnaryOperator
+        private readonly struct IdentityOperator_Single : IUnaryOperator
         {
             public bool CanVectorize => true;
             public float Invoke(float x) => x;
@@ -3437,7 +3437,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y)
         }
 
         /// <summary>x * x</summary>
-        private readonly struct SquaredOperator : IUnaryOperator
+        private readonly struct SquaredOperator_Single : IUnaryOperator
         {
             public bool CanVectorize => true;
             public float Invoke(float x) => x * x;
@@ -3445,7 +3445,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y)
         }
 
         /// <summary>MathF.Abs(x)</summary>
-        private readonly struct AbsoluteOperator : IUnaryOperator
+        private readonly struct AbsoluteOperator_Single : IUnaryOperator
         {
             public bool CanVectorize => true;
             public float Invoke(float x) => MathF.Abs(x);
@@ -3453,7 +3453,7 @@ public Vector<float> Invoke(Vector<float> x, Vector<float> y)
         }
 
         /// <summary>MathF.Exp(x)</summary>
-        private readonly struct ExpOperator : IUnaryOperator
+        private readonly struct ExpOperator_Single : IUnaryOperator
         {
             public bool CanVectorize => false;
             public float Invoke(float x) => MathF.Exp(x);
@@ -3463,7 +3463,7 @@ public Vector<float> Invoke(Vector<float> x) =>
         }
 
         /// <summary>MathF.Sinh(x)</summary>
-        private readonly struct SinhOperator : IUnaryOperator
+        private readonly struct SinhOperator_Single : IUnaryOperator
         {
             public bool CanVectorize => false;
             public float Invoke(float x) => MathF.Sinh(x);
@@ -3473,7 +3473,7 @@ public Vector<float> Invoke(Vector<float> x) =>
         }
 
         /// <summary>MathF.Cosh(x)</summary>
-        private readonly struct CoshOperator : IUnaryOperator
+        private readonly struct CoshOperator_Single : IUnaryOperator
         {
             public bool CanVectorize => false;
             public float Invoke(float x) => MathF.Cosh(x);
@@ -3483,7 +3483,7 @@ public Vector<float> Invoke(Vector<float> x) =>
         }
 
         /// <summary>MathF.Tanh(x)</summary>
-        private readonly struct TanhOperator : IUnaryOperator
+        private readonly struct TanhOperator_Single : IUnaryOperator
         {
             public bool CanVectorize => false;
             public float Invoke(float x) => MathF.Tanh(x);
@@ -3493,7 +3493,7 @@ public Vector<float> Invoke(Vector<float> x) =>
         }
 
         /// <summary>MathF.Log(x)</summary>
-        private readonly struct LogOperator : IUnaryOperator
+        private readonly struct LogOperator_Single : IUnaryOperator
         {
             public bool CanVectorize => false;
             public float Invoke(float x) => MathF.Log(x);
@@ -3503,7 +3503,7 @@ public Vector<float> Invoke(Vector<float> x) =>
         }
 
         /// <summary>MathF.Log2(x)</summary>
-        private readonly struct Log2Operator : IUnaryOperator
+        private readonly struct Log2Operator_Single : IUnaryOperator
         {
             public bool CanVectorize => false;
             public float Invoke(float x) => Log2(x);
@@ -3513,7 +3513,7 @@ public Vector<float> Invoke(Vector<float> x) =>
         }
 
         /// <summary>1f / (1f + MathF.Exp(-x))</summary>
-        private readonly struct SigmoidOperator : IUnaryOperator
+        private readonly struct SigmoidOperator_Single : IUnaryOperator
         {
             public bool CanVectorize => false;
             public float Invoke(float x) => 1.0f / (1.0f + MathF.Exp(-x));
diff --git a/src/libraries/System.Numerics.Tensors/tests/Helpers.cs b/src/libraries/System.Numerics.Tensors/tests/Helpers.cs
new file mode 100644
index 00000000000000..d6b5eef63d9dae
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/tests/Helpers.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Linq;
+
+namespace System.Numerics.Tensors.Tests
+{
+    internal static class Helpers
+    {
+        public static IEnumerable<int> TensorLengthsIncluding0 => Enumerable.Range(0, 257);
+
+        public static IEnumerable<int> TensorLengths => Enumerable.Range(1, 256);
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/tests/System.Numerics.Tensors.Tests.csproj b/src/libraries/System.Numerics.Tensors/tests/System.Numerics.Tensors.Tests.csproj
index be4a103d7256ce..11149747b7a1d8 100644
--- a/src/libraries/System.Numerics.Tensors/tests/System.Numerics.Tensors.Tests.csproj
+++ b/src/libraries/System.Numerics.Tensors/tests/System.Numerics.Tensors.Tests.csproj
@@ -6,11 +6,14 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <Compile Include="Helpers.cs" />
+    <Compile Include="TensorPrimitives.NonGeneric.Single.cs" />
     <Compile Include="TensorPrimitivesTests.cs" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
-    <Compile Include="TensorPrimitivesTests.netcore.cs" />
+    <Compile Include="TensorPrimitives.ConvertTo.cs" />
+    <Compile Include="TensorPrimitives.Generic.cs" />
   </ItemGroup>
   
   <ItemGroup>
@@ -18,4 +21,8 @@
     <ProjectReference Include="..\src\System.Numerics.Tensors.csproj" SkipUseReferenceAssembly="true" />
   </ItemGroup>
 
+  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework'">
+    <PackageReference Include="System.ValueTuple" Version="$(SystemValueTupleVersion)" />
+  </ItemGroup>
+
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.ConvertTo.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.ConvertTo.cs
new file mode 100644
index 00000000000000..f8f6c07e2174ee
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.ConvertTo.cs
@@ -0,0 +1,166 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using Xunit;
+
+namespace System.Numerics.Tensors.Tests
+{
+    public class ConvertToHalfTests
+    {
+        private readonly Random _random = new Random(42);
+
+        [Fact]
+        public void ConvertToHalf()
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<float> source = CreateAndFillSingleTensor(tensorLength);
+                foreach (int destLength in new[] { source.Length, source.Length + 1 })
+                {
+                    using BoundedMemory<Half> destination = BoundedMemory.Allocate<Half>(destLength);
+                    destination.Span.Fill(Half.Zero);
+
+                    TensorPrimitives.ConvertToHalf(source, destination);
+
+                    for (int i = 0; i < source.Length; i++)
+                    {
+                        Assert.Equal((Half)source[i], destination[i]);
+                    }
+
+                    if (destination.Length > source.Length)
+                    {
+                        for (int i = source.Length; i < destination.Length; i++)
+                        {
+                            Assert.Equal(Half.Zero, destination[i]);
+                        }
+                    }
+                }
+            });
+        }
+
+        [Fact]
+        public void ConvertToHalf_SpecialValues()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<float> source = CreateAndFillSingleTensor(tensorLength);
+                using BoundedMemory<Half> destination = BoundedMemory.Allocate<Half>(tensorLength);
+
+                // NaN, infinities, and 0s
+                source[_random.Next(source.Length)] = float.NaN;
+                source[_random.Next(source.Length)] = float.PositiveInfinity;
+                source[_random.Next(source.Length)] = float.NegativeInfinity;
+                source[_random.Next(source.Length)] = 0;
+                source[_random.Next(source.Length)] = float.NegativeZero;
+
+                TensorPrimitives.ConvertToHalf(source, destination);
+
+                for (int i = 0; i < source.Length; i++)
+                {
+                    Assert.Equal((Half)source[i], destination[i]);
+                }
+            });
+        }
+
+        [Fact]
+        public void ConvertToHalf_ThrowsForTooShortDestination()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<float> source = CreateAndFillSingleTensor(tensorLength);
+                Half[] destination = new Half[source.Length - 1];
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.ConvertToHalf(source, destination));
+            });
+        }
+
+        [Fact]
+        public void ConvertToSingle()
+        {
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<Half> source = BoundedMemory.Allocate<Half>(tensorLength);
+                for (int i = 0; i < source.Length; i++)
+                {
+                    source[i] = (Half)_random.NextSingle();
+                }
+
+                foreach (int destLength in new[] { source.Length, source.Length + 1 })
+                {
+                    using BoundedMemory<float> destination = CreateSingleTensor(destLength);
+                    destination.Span.Fill(0f);
+
+                    TensorPrimitives.ConvertToSingle(source, destination);
+
+                    for (int i = 0; i < source.Length; i++)
+                    {
+                        Assert.Equal((float)source[i], destination[i]);
+                    }
+
+                    if (destination.Length > source.Length)
+                    {
+                        for (int i = source.Length; i < destination.Length; i++)
+                        {
+                            Assert.Equal(0f, destination[i]);
+                        }
+                    }
+                }
+            });
+        }
+
+        [Fact]
+        public void ConvertToSingle_SpecialValues()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<Half> source = BoundedMemory.Allocate<Half>(tensorLength);
+                for (int i = 0; i < source.Length; i++)
+                {
+                    source[i] = (Half)_random.NextSingle();
+                }
+
+                using BoundedMemory<float> destination = CreateSingleTensor(tensorLength);
+
+                // NaN, infinities, and 0s
+                source[_random.Next(source.Length)] = Half.NaN;
+                source[_random.Next(source.Length)] = Half.PositiveInfinity;
+                source[_random.Next(source.Length)] = Half.NegativeInfinity;
+                source[_random.Next(source.Length)] = Half.Zero;
+                source[_random.Next(source.Length)] = Half.NegativeZero;
+
+                TensorPrimitives.ConvertToSingle(source, destination);
+
+                for (int i = 0; i < source.Length; i++)
+                {
+                    Assert.Equal((float)source[i], destination[i]);
+                }
+            });
+        }
+
+        [Fact]
+        public void ConvertToSingle_ThrowsForTooShortDestination()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                Half[] source = new Half[tensorLength];
+                using BoundedMemory<float> destination = CreateSingleTensor(source.Length - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.ConvertToSingle(source, destination));
+            });
+        }
+
+        public BoundedMemory<float> CreateSingleTensor(int size) => BoundedMemory.Allocate<float>(size);
+
+        public BoundedMemory<float> CreateAndFillSingleTensor(int size)
+        {
+            BoundedMemory<float> tensor = CreateSingleTensor(size);
+            Span<float> span = tensor;
+            for (int i = 0; i < span.Length; i++)
+            {
+                span[i] = (float)((_random.NextDouble() * 2) - 1); // For testing purposes, get a mix of negative and positive values.
+            }
+            return tensor;
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
new file mode 100644
index 00000000000000..de0269ca889246
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.Generic.cs
@@ -0,0 +1,295 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using Xunit;
+using Xunit.Sdk;
+
+namespace System.Numerics.Tensors.Tests
+{
+    public class DoubleGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<double> { }
+    public class SingleGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<float> { }
+    public class HalfGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<Half>
+    {
+        protected override void AssertEqualTolerance(Half expected, Half actual) => AssertEqualTolerance(expected, actual, Half.CreateTruncating(0.001));
+    }
+    public class NFloatGenericTensorPrimitives : GenericFloatingPointNumberTensorPrimitivesTests<NFloat> { }
+
+    public class SByteGenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<sbyte> { }
+    public class Int16GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<short> { }
+    public class Int32GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<int> { }
+    public class Int64GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<long> { }
+    public class IntPtrGenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<nint> { }
+    public class Int128GenericTensorPrimitives : GenericSignedIntegerTensorPrimitivesTests<Int128> { }
+
+    public class ByteGenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<byte> { }
+    public class UInt16GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<ushort> { }
+    public class CharGenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<char> { }
+    public class UInt32GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<uint> { }
+    public class UInt64GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<ulong> { }
+    public class UIntPtrGenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<nuint> { }
+    public class UInt128GenericTensorPrimitives : GenericIntegerTensorPrimitivesTests<UInt128> { }
+
+    public unsafe abstract class GenericFloatingPointNumberTensorPrimitivesTests<T> : GenericNumberTensorPrimitivesTests<T>
+        where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
+    {
+        protected override T Cosh(T x) => T.Cosh(x);
+        protected override void Cosh(ReadOnlySpan<T> x, Span<T> destination) => TensorPrimitives.Cosh(x, destination);
+        protected override T CosineSimilarity(ReadOnlySpan<T> x, ReadOnlySpan<T> y) => TensorPrimitives.CosineSimilarity(x, y);
+        protected override T Distance(ReadOnlySpan<T> x, ReadOnlySpan<T> y) => TensorPrimitives.Distance(x, y);
+        protected override void Exp(ReadOnlySpan<T> x, Span<T> destination) => TensorPrimitives.Exp(x, destination);
+        protected override T Exp(T x) => T.Exp(x);
+        protected override T Log(T x) => T.Log(x);
+        protected override void Log(ReadOnlySpan<T> x, Span<T> destination) => TensorPrimitives.Log(x, destination);
+        protected override T Log2(T x) => T.Log2(x);
+        protected override void Log2(ReadOnlySpan<T> x, Span<T> destination) => TensorPrimitives.Log2(x, destination);
+        protected override T Norm(ReadOnlySpan<T> x) => TensorPrimitives.Norm(x);
+        protected override void Sigmoid(ReadOnlySpan<T> x, Span<T> destination) => TensorPrimitives.Sigmoid(x, destination);
+        protected override void Sinh(ReadOnlySpan<T> x, Span<T> destination) => TensorPrimitives.Sinh(x, destination);
+        protected override T Sinh(T x) => T.Sinh(x);
+        protected override void SoftMax(ReadOnlySpan<T> x, Span<T> destination) => TensorPrimitives.SoftMax(x, destination);
+        protected override T Sqrt(T x) => T.Sqrt(x);
+        protected override void Tanh(ReadOnlySpan<T> x, Span<T> destination) => TensorPrimitives.Tanh(x, destination);
+        protected override T Tanh(T x) => T.Tanh(x);
+
+        protected override T NaN => T.NaN;
+
+        protected override T NextRandom() => T.CreateTruncating((Random.NextDouble() * 2) - 1); // For testing purposes, get a mix of negative and positive values.
+
+        protected override IEnumerable<T> GetSpecialValues()
+        {
+            // NaN
+            yield return T.CreateTruncating(BitConverter.UInt32BitsToSingle(0xFFC0_0000)); // -qNaN / float.NaN
+            yield return T.CreateTruncating(BitConverter.UInt32BitsToSingle(0xFFFF_FFFF)); // -qNaN / all-bits-set
+            yield return T.CreateTruncating(BitConverter.UInt32BitsToSingle(0x7FC0_0000)); // +qNaN
+            yield return T.CreateTruncating(BitConverter.UInt32BitsToSingle(0xFFA0_0000)); // -sNaN
+            yield return T.CreateTruncating(BitConverter.UInt32BitsToSingle(0x7FA0_0000)); // +sNaN
+
+            // +Infinity, -Infinity
+            yield return T.CreateTruncating(float.PositiveInfinity);
+            yield return T.CreateTruncating(float.NegativeInfinity);
+
+            // +Zero, -Zero
+            yield return T.Zero;
+            yield return T.NegativeZero;
+
+            // Subnormals
+            yield return T.Epsilon;
+            yield return -T.Epsilon;
+            yield return T.CreateTruncating(BitConverter.UInt32BitsToSingle(0x007F_FFFF));
+            yield return T.CreateTruncating(BitConverter.UInt32BitsToSingle(0x807F_FFFF));
+
+            // Normals
+            yield return T.CreateTruncating(BitConverter.UInt32BitsToSingle(0x0080_0000));
+            yield return T.CreateTruncating(BitConverter.UInt32BitsToSingle(0x8080_0000));
+            yield return T.CreateTruncating(BitConverter.UInt32BitsToSingle(0x7F7F_FFFF)); // MaxValue
+            yield return T.CreateTruncating(BitConverter.UInt32BitsToSingle(0xFF7F_FFFF)); // MinValue
+        }
+
+        protected override void SetSpecialValues(Span<T> x, Span<T> y)
+        {
+            int pos;
+
+            // NaNs
+            pos = Random.Next(x.Length);
+            x[pos] = T.NaN;
+            y[pos] = T.CreateTruncating(BitConverter.UInt32BitsToSingle(0x7FC0_0000));
+
+            // +Infinity, -Infinity
+            pos = Random.Next(x.Length);
+            x[pos] = T.PositiveInfinity;
+            y[pos] = T.NegativeInfinity;
+
+            // +Zero, -Zero
+            pos = Random.Next(x.Length);
+            x[pos] = T.Zero;
+            y[pos] = T.NegativeZero;
+
+            // +Epsilon, -Epsilon
+            pos = Random.Next(x.Length);
+            x[pos] = T.Epsilon;
+            y[pos] = -T.Epsilon;
+
+            // Same magnitude, opposite sign
+            pos = Random.Next(x.Length);
+            x[pos] = T.CreateTruncating(5);
+            y[pos] = T.CreateTruncating(-5);
+        }
+    }
+
+    public unsafe abstract class GenericSignedIntegerTensorPrimitivesTests<T> : GenericIntegerTensorPrimitivesTests<T>
+        where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T>
+    {
+        [Fact]
+        public void Abs_MinValue_Throws()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                FillTensor(x.Span, T.MinValue);
+                x[^1] = T.MinValue;
+
+                Assert.Throws<OverflowException>(() => Abs(x, destination));
+            });
+        }
+
+        [Fact]
+        public void SumOfMagnitudes_MinValue_Throws()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+
+                FillTensor(x.Span, T.MinValue);
+                x[^1] = T.MinValue;
+
+                Assert.Throws<OverflowException>(() => SumOfMagnitudes(x));
+            });
+        }
+    }
+
+    public unsafe abstract class GenericIntegerTensorPrimitivesTests<T> : GenericNumberTensorPrimitivesTests<T>
+        where T : unmanaged, IBinaryInteger<T>, IMinMaxValue<T>
+    {
+        [Fact]
+        public void Divide_TwoTensors_ByZero_Throws()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                FillTensor(y.Span, T.Zero);
+                y[^1] = T.Zero;
+
+                Exception e = Record.Exception(() => Divide(x, y, destination));
+                Assert.True(e is DivideByZeroException or ArgumentOutOfRangeException); // TODO https://github.com/dotnet/runtime/issues/94593: Fix exception type
+            });
+        }
+
+        [Fact]
+        public void Divide_TensorScalar_ByZero_Throw()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                Exception e = Record.Exception(() => Divide(x, T.Zero, destination));
+                Assert.True(e is DivideByZeroException or ArgumentOutOfRangeException); // TODO https://github.com/dotnet/runtime/issues/94593: Fix exception type
+            });
+        }
+    }
+
+    public unsafe abstract class GenericNumberTensorPrimitivesTests<T> : TensorPrimitivesTests<T>
+        where T : unmanaged, INumber<T>, IMinMaxValue<T>
+    {
+        protected override void Abs(ReadOnlySpan<T> x, Span<T> destination) => TensorPrimitives.Abs(x, destination);
+        protected override T Abs(T x) => T.Abs(x);
+        protected override void Add(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => TensorPrimitives.Add(x, y, destination);
+        protected override void Add(ReadOnlySpan<T> x, T y, Span<T> destination) => TensorPrimitives.Add(x, y, destination);
+        protected override T Add(T x, T y) => x + y;
+        protected override void AddMultiply(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> z, Span<T> destination) => TensorPrimitives.AddMultiply(x, y, z, destination);
+        protected override void AddMultiply(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T z, Span<T> destination) => TensorPrimitives.AddMultiply(x, y, z, destination);
+        protected override void AddMultiply(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> z, Span<T> destination) => TensorPrimitives.AddMultiply(x, y, z, destination);
+        protected override T AddMultiply(T x, T y, T z) => (x + y) * z;
+        protected override void Divide(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => TensorPrimitives.Divide(x, y, destination);
+        protected override void Divide(ReadOnlySpan<T> x, T y, Span<T> destination) => TensorPrimitives.Divide(x, y, destination);
+        protected override T Divide(T x, T y) => x / y;
+        protected override T Dot(ReadOnlySpan<T> x, ReadOnlySpan<T> y) => TensorPrimitives.Dot(x, y);
+        protected override T Max(ReadOnlySpan<T> x) => TensorPrimitives.Max(x);
+        protected override void Max(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => TensorPrimitives.Max(x, y, destination);
+        protected override T Max(T x, T y) => T.Max(x, y);
+        protected override T MaxMagnitude(ReadOnlySpan<T> x) => TensorPrimitives.MaxMagnitude(x);
+        protected override void MaxMagnitude(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => TensorPrimitives.MaxMagnitude(x, y, destination);
+        protected override T MaxMagnitude(T x, T y) => T.MaxMagnitude(x, y);
+        protected override T Min(ReadOnlySpan<T> x) => TensorPrimitives.Min(x);
+        protected override void Min(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => TensorPrimitives.Min(x, y, destination);
+        protected override T Min(T x, T y) => T.Min(x, y);
+        protected override T MinMagnitude(ReadOnlySpan<T> x) => TensorPrimitives.MinMagnitude(x);
+        protected override void MinMagnitude(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => TensorPrimitives.MinMagnitude(x, y, destination);
+        protected override T MinMagnitude(T x, T y) => T.MinMagnitude(x, y);
+        protected override void Multiply(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => TensorPrimitives.Multiply(x, y, destination);
+        protected override void Multiply(ReadOnlySpan<T> x, T y, Span<T> destination) => TensorPrimitives.Multiply(x, y, destination);
+        protected override T Multiply(T x, T y) => x * y;
+        protected override void MultiplyAdd(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> z, Span<T> destination) => TensorPrimitives.MultiplyAdd(x, y, z, destination);
+        protected override void MultiplyAdd(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T z, Span<T> destination) => TensorPrimitives.MultiplyAdd(x, y, z, destination);
+        protected override void MultiplyAdd(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> z, Span<T> destination) => TensorPrimitives.MultiplyAdd(x, y, z, destination);
+        protected override void Negate(ReadOnlySpan<T> x, Span<T> destination) => TensorPrimitives.Negate(x, destination);
+        protected override T Product(ReadOnlySpan<T> x) => TensorPrimitives.Product(x);
+        protected override T ProductOfSums(ReadOnlySpan<T> x, ReadOnlySpan<T> y) => TensorPrimitives.ProductOfSums(x, y);
+        protected override T ProductOfDifferences(ReadOnlySpan<T> x, ReadOnlySpan<T> y) => TensorPrimitives.ProductOfDifferences(x, y);
+        protected override void Subtract(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination) => TensorPrimitives.Subtract(x, y, destination);
+        protected override void Subtract(ReadOnlySpan<T> x, T y, Span<T> destination) => TensorPrimitives.Subtract(x, y, destination);
+        protected override T Subtract(T x, T y) => x - y;
+        protected override T Sum(ReadOnlySpan<T> x) => TensorPrimitives.Sum(x);
+        protected override T SumOfMagnitudes(ReadOnlySpan<T> x) => TensorPrimitives.SumOfMagnitudes(x);
+        protected override T SumOfSquares(ReadOnlySpan<T> x) => TensorPrimitives.SumOfSquares(x);
+
+        protected override T ConvertFromSingle(float f) => T.CreateTruncating(f);
+        protected override bool IsFloatingPoint => typeof(T) == typeof(Half) || base.IsFloatingPoint;
+
+        protected override T NextRandom()
+        {
+            T value = default;
+            Random.NextBytes(MemoryMarshal.AsBytes(new Span<T>(ref value)));
+            return value;
+        }
+
+        protected override T NegativeZero => -T.Zero;
+        protected override T Zero => T.Zero;
+        protected override T One => T.One;
+        protected override T NegativeOne => -T.One;
+        protected override T MinValue => T.MinValue;
+
+        protected override IEnumerable<(int Length, T Element)> VectorLengthAndIteratedRange(T min, T max, T increment)
+        {
+            foreach (int length in new[] { 4, 8, 16 })
+            {
+                for (T f = min; f <= max; f += increment)
+                {
+                    yield return (length, f);
+                }
+            }
+        }
+
+        protected override void AssertEqualTolerance(T expected, T actual) => AssertEqualTolerance(expected, actual, T.CreateTruncating(0.0001));
+
+        protected override void AssertEqualTolerance(T expected, T actual, T tolerance)
+        {
+            T diff = T.Abs(expected - actual);
+            if (diff > tolerance && diff > T.Max(T.Abs(expected), T.Abs(actual)) * tolerance)
+            {
+                throw EqualException.ForMismatchedValues(expected, actual);
+            }
+        }
+
+        protected override T Cosh(T x) => throw new NotSupportedException();
+        protected override void Cosh(ReadOnlySpan<T> x, Span<T> destination) => throw new NotSupportedException();
+        protected override T CosineSimilarity(ReadOnlySpan<T> x, ReadOnlySpan<T> y) => throw new NotSupportedException();
+        protected override T Distance(ReadOnlySpan<T> x, ReadOnlySpan<T> y) => throw new NotSupportedException();
+        protected override void Exp(ReadOnlySpan<T> x, Span<T> destination) => throw new NotSupportedException();
+        protected override T Exp(T x) => throw new NotSupportedException();
+        protected override T Log(T x) => throw new NotSupportedException();
+        protected override void Log(ReadOnlySpan<T> x, Span<T> destination) => throw new NotSupportedException();
+        protected override T Log2(T x) => throw new NotSupportedException();
+        protected override void Log2(ReadOnlySpan<T> x, Span<T> destination) => throw new NotSupportedException();
+        protected override T Norm(ReadOnlySpan<T> x) => throw new NotSupportedException(    );
+        protected override void Sigmoid(ReadOnlySpan<T> x, Span<T> destination) => throw new NotSupportedException();
+        protected override void Sinh(ReadOnlySpan<T> x, Span<T> destination) => throw new NotSupportedException();
+        protected override T Sinh(T x) => throw new NotSupportedException();
+        protected override void SoftMax(ReadOnlySpan<T> x, Span<T> destination) => throw new NotSupportedException();
+        protected override T Sqrt(T x) => throw new NotSupportedException();
+        protected override void Tanh(ReadOnlySpan<T> x, Span<T> destination) => throw new NotSupportedException();
+        protected override T Tanh(T x) => throw new NotSupportedException();
+        protected override T NaN => throw new NotSupportedException();
+        protected override IEnumerable<T> GetSpecialValues() => Enumerable.Empty<T>();
+        protected override void SetSpecialValues(Span<T> x, Span<T> y) { }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.NonGeneric.Single.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.NonGeneric.Single.cs
new file mode 100644
index 00000000000000..50e3b3dae77d42
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitives.NonGeneric.Single.cs
@@ -0,0 +1,376 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using Xunit;
+using Xunit.Sdk;
+
+namespace System.Numerics.Tensors.Tests
+{
+    public unsafe class NonGenericSingleTensorPrimitivesTests : TensorPrimitivesTests<float>
+    {
+        protected override void Abs(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.Abs(x, destination);
+        protected override float Abs(float x) => MathF.Abs(x);
+        protected override void Add(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) => TensorPrimitives.Add(x, y, destination);
+        protected override void Add(ReadOnlySpan<float> x, float y, Span<float> destination) => TensorPrimitives.Add(x, y, destination);
+        protected override float Add(float x, float y) => x + y;
+        protected override void AddMultiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, ReadOnlySpan<float> z, Span<float> destination) => TensorPrimitives.AddMultiply(x, y, z, destination);
+        protected override void AddMultiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, float z, Span<float> destination) => TensorPrimitives.AddMultiply(x, y, z, destination);
+        protected override void AddMultiply(ReadOnlySpan<float> x, float y, ReadOnlySpan<float> z, Span<float> destination) => TensorPrimitives.AddMultiply(x, y, z, destination);
+        protected override float AddMultiply(float x, float y, float z) => (x + y) * z;
+        protected override void Cosh(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.Cosh(x, destination);
+        protected override float Cosh(float x) => MathF.Cosh(x);
+        protected override float CosineSimilarity(ReadOnlySpan<float> x, ReadOnlySpan<float> y) => TensorPrimitives.CosineSimilarity(x, y);
+        protected override float Distance(ReadOnlySpan<float> x, ReadOnlySpan<float> y) => TensorPrimitives.Distance(x, y);
+        protected override void Divide(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) => TensorPrimitives.Divide(x, y, destination);
+        protected override void Divide(ReadOnlySpan<float> x, float y, Span<float> destination) => TensorPrimitives.Divide(x, y, destination);
+        protected override float Divide(float x, float y) => x / y;
+        protected override float Dot(ReadOnlySpan<float> x, ReadOnlySpan<float> y) => TensorPrimitives.Dot(x, y);
+        protected override void Exp(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.Exp(x, destination);
+        protected override float Exp(float x) => MathF.Exp(x);
+        protected override float Log(float x) => MathF.Log(x);
+        protected override void Log(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.Log(x, destination);
+        protected override float Log2(float x) => MathF.Log(x, 2);
+        protected override void Log2(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.Log2(x, destination);
+        protected override float Max(ReadOnlySpan<float> x) => TensorPrimitives.Max(x);
+        protected override void Max(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) => TensorPrimitives.Max(x, y, destination);
+        protected override float Max(float x, float y) => MathF.Max(x, y);
+        protected override float MaxMagnitude(ReadOnlySpan<float> x) => TensorPrimitives.MaxMagnitude(x);
+        protected override void MaxMagnitude(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) => TensorPrimitives.MaxMagnitude(x, y, destination);
+        protected override float MaxMagnitude(float x, float y)
+        {
+            float ax = MathF.Abs(x), ay = MathF.Abs(y);
+            return (ax > ay) || float.IsNaN(ax) || (ax == ay && *(int*)&x >= 0) ? x : y;
+        }
+        protected override float Min(ReadOnlySpan<float> x) => TensorPrimitives.Min(x);
+        protected override void Min(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) => TensorPrimitives.Min(x, y, destination);
+        protected override float Min(float x, float y) => MathF.Min(x, y);
+        protected override float MinMagnitude(ReadOnlySpan<float> x) => TensorPrimitives.MinMagnitude(x);
+        protected override void MinMagnitude(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) => TensorPrimitives.MinMagnitude(x, y, destination);
+        protected override float MinMagnitude(float x, float y)
+        {
+            float ax = MathF.Abs(x), ay = MathF.Abs(y);
+            return (ax < ay) || float.IsNaN(ax) || (ax == ay && *(int*)&x < 0) ? x : y;
+        }
+        protected override void Multiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) => TensorPrimitives.Multiply(x, y, destination);
+        protected override void Multiply(ReadOnlySpan<float> x, float y, Span<float> destination) => TensorPrimitives.Multiply(x, y, destination);
+        protected override float Multiply(float x, float y) => x * y;
+        protected override void MultiplyAdd(ReadOnlySpan<float> x, ReadOnlySpan<float> y, ReadOnlySpan<float> z, Span<float> destination) => TensorPrimitives.MultiplyAdd(x, y, z, destination);
+        protected override void MultiplyAdd(ReadOnlySpan<float> x, ReadOnlySpan<float> y, float z, Span<float> destination) => TensorPrimitives.MultiplyAdd(x, y, z, destination);
+        protected override void MultiplyAdd(ReadOnlySpan<float> x, float y, ReadOnlySpan<float> z, Span<float> destination) => TensorPrimitives.MultiplyAdd(x, y, z, destination);
+        protected override void Negate(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.Negate(x, destination);
+        protected override float Norm(ReadOnlySpan<float> x) => TensorPrimitives.Norm(x);
+        protected override float Product(ReadOnlySpan<float> x) => TensorPrimitives.Product(x);
+        protected override float ProductOfSums(ReadOnlySpan<float> x, ReadOnlySpan<float> y) => TensorPrimitives.ProductOfSums(x, y);
+        protected override float ProductOfDifferences(ReadOnlySpan<float> x, ReadOnlySpan<float> y) => TensorPrimitives.ProductOfDifferences(x, y);
+        protected override void Sigmoid(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.Sigmoid(x, destination);
+        protected override void Sinh(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.Sinh(x, destination);
+        protected override float Sinh(float x) => MathF.Sinh(x);
+        protected override void SoftMax(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.SoftMax(x, destination);
+        protected override float Sqrt(float x) => MathF.Sqrt(x);
+        protected override void Subtract(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination) => TensorPrimitives.Subtract(x, y, destination);
+        protected override void Subtract(ReadOnlySpan<float> x, float y, Span<float> destination) => TensorPrimitives.Subtract(x, y, destination);
+        protected override float Subtract(float x, float y) => x - y;
+        protected override float Sum(ReadOnlySpan<float> x) => TensorPrimitives.Sum(x);
+        protected override float SumOfMagnitudes(ReadOnlySpan<float> x) => TensorPrimitives.SumOfMagnitudes(x);
+        protected override float SumOfSquares(ReadOnlySpan<float> x) => TensorPrimitives.SumOfSquares(x);
+        protected override void Tanh(ReadOnlySpan<float> x, Span<float> destination) => TensorPrimitives.Tanh(x, destination);
+        protected override float Tanh(float x) => MathF.Tanh(x);
+
+        protected override float ConvertFromSingle(float f) => f;
+
+        protected override float NaN => float.NaN;
+        protected override float NegativeZero => -0f;
+        protected override float Zero => 0f;
+        protected override float One => 1f;
+        protected override float NegativeOne => -1f;
+        protected override float MinValue => float.MinValue;
+
+        protected override IEnumerable<(int Length, float Element)> VectorLengthAndIteratedRange(float min, float max, float increment)
+        {
+            foreach (int length in new[] { 4, 8, 16 })
+            {
+                for (float f = min; f <= max; f += increment)
+                {
+                    yield return (length, f);
+                }
+            }
+        }
+
+        protected override float NextRandom() => (float)((Random.NextDouble() * 2) - 1); // For testing purposes, get a mix of negative and positive values.
+
+        protected override void AssertEqualTolerance(float expected, float actual) => AssertEqualTolerance(expected, actual, 0.0001f);
+
+        protected override void AssertEqualTolerance(float expected, float actual, float tolerance)
+        {
+            double diff = Math.Abs((double)expected - (double)actual);
+            if (diff > tolerance && diff > Math.Max(Math.Abs(expected), Math.Abs(actual)) * tolerance)
+            {
+                throw EqualException.ForMismatchedValues(expected, actual);
+            }
+        }
+
+        protected override IEnumerable<float> GetSpecialValues()
+        {
+            // NaN
+            yield return UInt32ToSingle(0xFFC0_0000); // -qNaN / float.NaN
+            yield return UInt32ToSingle(0xFFFF_FFFF); // -qNaN / all-bits-set
+            yield return UInt32ToSingle(0x7FC0_0000); // +qNaN
+            yield return UInt32ToSingle(0xFFA0_0000); // -sNaN
+            yield return UInt32ToSingle(0x7FA0_0000); // +sNaN
+
+            // +Infinity, -Infinity
+            yield return float.PositiveInfinity;
+            yield return float.NegativeInfinity;
+
+            // +Zero, -Zero
+            yield return +0.0f;
+            yield return -0.0f;
+
+            // Subnormals
+            yield return +float.Epsilon;
+            yield return -float.Epsilon;
+            yield return UInt32ToSingle(0x007F_FFFF);
+            yield return UInt32ToSingle(0x807F_FFFF);
+
+            // Normals
+            yield return UInt32ToSingle(0x0080_0000);
+            yield return UInt32ToSingle(0x8080_0000);
+            yield return UInt32ToSingle(0x7F7F_FFFF); // MaxValue
+            yield return UInt32ToSingle(0xFF7F_FFFF); // MinValue
+        }
+
+        protected override void SetSpecialValues(Span<float> x, Span<float> y)
+        {
+            int pos;
+
+            // NaNs
+            pos = Random.Next(x.Length);
+            x[pos] = float.NaN;
+            y[pos] = UInt32ToSingle(0x7FC0_0000);
+
+            // +Infinity, -Infinity
+            pos = Random.Next(x.Length);
+            x[pos] = float.PositiveInfinity;
+            y[pos] = float.NegativeInfinity;
+
+            // +Zero, -Zero
+            pos = Random.Next(x.Length);
+            x[pos] = +0.0f;
+            y[pos] = -0.0f;
+
+            // +Epsilon, -Epsilon
+            pos = Random.Next(x.Length);
+            x[pos] = +float.Epsilon;
+            y[pos] = -float.Epsilon;
+
+            // Same magnitude, opposite sign
+            pos = Random.Next(x.Length);
+            x[pos] = +5.0f;
+            y[pos] = -5.0f;
+        }
+
+        private static unsafe float UInt32ToSingle(uint i) => *(float*)&i;
+
+        // TODO: Move these IndexOf tests to the base class once generic versions are implemented.
+        #region IndexOfMax
+        [Fact]
+        public void IndexOfMax_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, TensorPrimitives.IndexOfMax(ReadOnlySpan<float>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMax()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = Enumerable.Max(MemoryMarshal.ToEnumerable<float>(x.Memory)) + 1;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMax(x));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMax_FirstNaNReturned()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = float.NaN;
+                    x[tensorLength - 1] = float.NaN;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMax(x));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMax_Negative0LesserThanPositive0()
+        {
+            Assert.Equal(1, TensorPrimitives.IndexOfMax([-0f, +0f]));
+            Assert.Equal(0, TensorPrimitives.IndexOfMax([-0f, -0f, -0f, -0f]));
+            Assert.Equal(4, TensorPrimitives.IndexOfMax([-0f, -0f, -0f, -0f, +0f, +0f, +0f]));
+            Assert.Equal(0, TensorPrimitives.IndexOfMax([+0f, -0f]));
+            Assert.Equal(1, TensorPrimitives.IndexOfMax([-1, -0f]));
+            Assert.Equal(2, TensorPrimitives.IndexOfMax([-1, -0f, 1]));
+        }
+        #endregion
+
+        #region IndexOfMaxMagnitude
+        [Fact]
+        public void IndexOfMaxMagnitude_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, TensorPrimitives.IndexOfMaxMagnitude(ReadOnlySpan<float>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMaxMagnitude()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = Enumerable.Max(MemoryMarshal.ToEnumerable<float>(x.Memory), Math.Abs) + 1;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMaxMagnitude(x));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxMagnitude_FirstNaNReturned()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = float.NaN;
+                    x[tensorLength - 1] = float.NaN;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMaxMagnitude(x));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMaxMagnitude_Negative0LesserThanPositive0()
+        {
+            Assert.Equal(0, TensorPrimitives.IndexOfMaxMagnitude([-0f, -0f, -0f, -0f]));
+            Assert.Equal(1, TensorPrimitives.IndexOfMaxMagnitude([-0f, +0f]));
+            Assert.Equal(1, TensorPrimitives.IndexOfMaxMagnitude([-0f, +0f, +0f, +0f]));
+            Assert.Equal(0, TensorPrimitives.IndexOfMaxMagnitude([+0f, -0f]));
+            Assert.Equal(0, TensorPrimitives.IndexOfMaxMagnitude([-1, -0f]));
+            Assert.Equal(2, TensorPrimitives.IndexOfMaxMagnitude([-1, -0f, 1]));
+        }
+        #endregion
+
+        #region IndexOfMin
+        [Fact]
+        public void IndexOfMin_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, TensorPrimitives.IndexOfMin(ReadOnlySpan<float>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMin()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = Enumerable.Min(MemoryMarshal.ToEnumerable<float>(x.Memory)) - 1;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMin(x));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMin_FirstNaNReturned()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = float.NaN;
+                    x[tensorLength - 1] = float.NaN;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMin(x));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMin_Negative0LesserThanPositive0()
+        {
+            Assert.Equal(0, TensorPrimitives.IndexOfMin([-0f, +0f]));
+            Assert.Equal(1, TensorPrimitives.IndexOfMin([+0f, -0f]));
+            Assert.Equal(1, TensorPrimitives.IndexOfMin([+0f, -0f, -0f, -0f, -0f]));
+            Assert.Equal(0, TensorPrimitives.IndexOfMin([-1, -0f]));
+            Assert.Equal(0, TensorPrimitives.IndexOfMin([-1, -0f, 1]));
+        }
+        #endregion
+
+        #region IndexOfMinMagnitude
+        [Fact]
+        public void IndexOfMinMagnitude_ReturnsNegative1OnEmpty()
+        {
+            Assert.Equal(-1, TensorPrimitives.IndexOfMinMagnitude(ReadOnlySpan<float>.Empty));
+        }
+
+        [Fact]
+        public void IndexOfMinMagnitude()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<float> x = CreateTensor(tensorLength);
+                    for (int i = 0; i < x.Length; i++)
+                    {
+                        x[i] = i % 2 == 0 ? 42 : -42;
+                    }
+
+                    x[expected] = -41;
+
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMinMagnitude(x));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinMagnitude_FirstNaNReturned()
+        {
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
+                    x[expected] = float.NaN;
+                    x[tensorLength - 1] = float.NaN;
+                    Assert.Equal(expected, TensorPrimitives.IndexOfMinMagnitude(x));
+                }
+            });
+        }
+
+        [Fact]
+        public void IndexOfMinMagnitude_Negative0LesserThanPositive0()
+        {
+            Assert.Equal(0, TensorPrimitives.IndexOfMinMagnitude([-0f, -0f, -0f, -0f]));
+            Assert.Equal(0, TensorPrimitives.IndexOfMinMagnitude([-0f, +0f]));
+            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([+0f, -0f]));
+            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([+0f, -0f, -0f, -0f]));
+            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([-1, -0f]));
+            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([-1, -0f, 1]));
+        }
+        #endregion
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
index 847fa34a4470cd..9083d7d8bf8962 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
@@ -6,111 +6,141 @@
 using System.Linq;
 using System.Runtime.InteropServices;
 using Xunit;
-using Xunit.Sdk;
-
-#pragma warning disable xUnit1025 // reporting duplicate test cases due to not distinguishing 0.0 from -0.0
 
 namespace System.Numerics.Tensors.Tests
 {
-    public static partial class TensorPrimitivesTests
+    public abstract class TensorPrimitivesTests<T> where T : unmanaged, IEquatable<T>
     {
+        #region Abstract Methods Under Test
+        protected abstract void Abs(ReadOnlySpan<T> x, Span<T> destination);
+        protected abstract void Add(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination);
+        protected abstract void Add(ReadOnlySpan<T> x, T y, Span<T> destination);
+        protected abstract void AddMultiply(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> z, Span<T> destination);
+        protected abstract void AddMultiply(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T z, Span<T> destination);
+        protected abstract void AddMultiply(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> z, Span<T> destination);
+        protected abstract void Cosh(ReadOnlySpan<T> x, Span<T> destination);
+        protected abstract T CosineSimilarity(ReadOnlySpan<T> x, ReadOnlySpan<T> y);
+        protected abstract T Distance(ReadOnlySpan<T> x, ReadOnlySpan<T> y);
+        protected abstract void Divide(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination);
+        protected abstract void Divide(ReadOnlySpan<T> x, T y, Span<T> destination);
+        protected abstract T Dot(ReadOnlySpan<T> x, ReadOnlySpan<T> y);
+        protected abstract void Exp(ReadOnlySpan<T> x, Span<T> destination);
+        protected abstract void Log(ReadOnlySpan<T> x, Span<T> destination);
+        protected abstract void Log2(ReadOnlySpan<T> x, Span<T> destination);
+        protected abstract T Max(ReadOnlySpan<T> x);
+        protected abstract void Max(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination);
+        protected abstract T Max(T x, T y);
+        protected abstract T MaxMagnitude(ReadOnlySpan<T> x);
+        protected abstract void MaxMagnitude(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination);
+        protected abstract T MaxMagnitude(T x, T y);
+        protected abstract T Min(ReadOnlySpan<T> x);
+        protected abstract void Min(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination);
+        protected abstract T Min(T x, T y);
+        protected abstract T MinMagnitude(ReadOnlySpan<T> x);
+        protected abstract void MinMagnitude(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination);
+        protected abstract T MinMagnitude(T x, T y);
+        protected abstract void Multiply(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination);
+        protected abstract void Multiply(ReadOnlySpan<T> x, T y, Span<T> destination);
+        protected abstract void MultiplyAdd(ReadOnlySpan<T> x, ReadOnlySpan<T> y, ReadOnlySpan<T> z, Span<T> destination);
+        protected abstract void MultiplyAdd(ReadOnlySpan<T> x, ReadOnlySpan<T> y, T z, Span<T> destination);
+        protected abstract void MultiplyAdd(ReadOnlySpan<T> x, T y, ReadOnlySpan<T> z, Span<T> destination);
+        protected abstract void Negate(ReadOnlySpan<T> x, Span<T> destination);
+        protected abstract T Norm(ReadOnlySpan<T> x);
+        protected abstract T Product(ReadOnlySpan<T> x);
+        protected abstract T ProductOfSums(ReadOnlySpan<T> x, ReadOnlySpan<T> y);
+        protected abstract T ProductOfDifferences(ReadOnlySpan<T> x, ReadOnlySpan<T> y);
+        protected abstract void Sigmoid(ReadOnlySpan<T> x, Span<T> destination);
+        protected abstract void Sinh(ReadOnlySpan<T> x, Span<T> destination);
+        protected abstract void SoftMax(ReadOnlySpan<T> x, Span<T> destination);
+        protected abstract void Subtract(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination);
+        protected abstract void Subtract(ReadOnlySpan<T> x, T y, Span<T> destination);
+        protected abstract T Sum(ReadOnlySpan<T> x);
+        protected abstract T SumOfMagnitudes(ReadOnlySpan<T> x);
+        protected abstract T SumOfSquares(ReadOnlySpan<T> x);
+        protected abstract void Tanh(ReadOnlySpan<T> x, Span<T> destination);
+        #endregion
+
+        #region Abstract Validation
+        protected abstract T Abs(T x);
+        protected abstract T Add(T x, T y);
+        protected abstract T AddMultiply(T x, T y, T z);
+        protected abstract T Cosh(T x);
+        protected abstract T Divide(T x, T y);
+        protected abstract T Exp(T x);
+        protected abstract T Log(T x);
+        protected abstract T Log2(T x);
+        protected abstract T Multiply(T x, T y);
+        protected abstract T Sinh(T x);
+        protected abstract T Sqrt(T x);
+        protected abstract T Subtract(T x, T y);
+        protected abstract T Tanh(T x);
+
+        protected abstract T NaN { get; }
+        protected abstract T NegativeZero { get; }
+        protected abstract T Zero { get; }
+        protected abstract T One { get; }
+        protected abstract T NegativeOne  { get; }
+        protected abstract T MinValue { get; }
+        #endregion
+
         #region Test Utilities
-        public static IEnumerable<object[]> TensorLengthsIncluding0 =>
-            TensorLengths.Concat(new object[][] { [0] });
+        protected virtual bool IsFloatingPoint => typeof(T) == typeof(float) || typeof(T) == typeof(double);
 
-        public static IEnumerable<object[]> TensorLengths =>
-            from length in Enumerable.Range(1, 256)
-            select new object[] { length };
+        protected abstract T ConvertFromSingle(float f);
 
-        public static IEnumerable<object[]> VectorLengthAndIteratedRange(float min, float max, float increment)
-        {
-            foreach (int length in new[] { 4, 8, 16 })
-            {
-                for (float f = min; f <= max; f += increment)
-                {
-                    yield return new object[] { length, f };
-                }
-            }
-        }
+        protected abstract IEnumerable<T> GetSpecialValues();
+
+        /// <summary>
+        /// Loads a variety of special values (e.g. NaN) into random positions in <paramref name="x"/>
+        /// and related values into the corresponding positions in <paramref name="y"/>.
+        /// </summary>
+        protected abstract void SetSpecialValues(Span<T> x, Span<T> y);
 
-        private static readonly Random s_random = new Random(20230828);
+        protected abstract T NextRandom();
 
-        private static BoundedMemory<float> CreateTensor(int size) => BoundedMemory.Allocate<float>(size);
+        protected abstract void AssertEqualTolerance(T expected, T actual);
 
-        private static BoundedMemory<float> CreateAndFillTensor(int size)
+        protected abstract void AssertEqualTolerance(T expected, T actual, T tolerance);
+
+        protected abstract IEnumerable<(int Length, T Element)> VectorLengthAndIteratedRange(T min, T max, T increment);
+
+        protected Random Random { get; } = new Random(42);
+
+        protected BoundedMemory<T> CreateTensor(int size) => BoundedMemory.Allocate<T>(size);
+
+        public BoundedMemory<T> CreateAndFillTensor(int size)
         {
-            BoundedMemory<float> tensor = CreateTensor(size);
-            FillTensor(tensor.Span);
+            BoundedMemory<T> tensor = CreateTensor(size);
+            FillTensor(tensor);
             return tensor;
         }
 
-        private static void FillTensor(Span<float> tensor)
+        protected void FillTensor(Span<T> span)
         {
-            for (int i = 0; i < tensor.Length; i++)
+            for (int i = 0; i < span.Length; i++)
             {
-                tensor[i] = NextSingle();
+                span[i] = NextRandom();
             }
         }
 
-        private static float NextSingle() =>
-            // For testing purposes, get a mix of negative and positive values.
-            (float)((s_random.NextDouble() * 2) - 1);
-
-        private static void AssertEqualTolerance(double expected, double actual, double tolerance = 0.00001f)
+        protected void FillTensor(Span<T> span, T avoid)
         {
-            double diff = Math.Abs(expected - actual);
-            if (diff > tolerance &&
-                diff > Math.Max(Math.Abs(expected), Math.Abs(actual)) * tolerance)
+            for (int i = 0; i < span.Length; i++)
             {
-                throw EqualException.ForMismatchedValues(expected, actual);
+                span[i] = NextRandom(avoid);
             }
         }
 
-        private static unsafe float MathFMaxMagnitude(float x, float y)
-        {
-            float ax = MathF.Abs(x), ay = MathF.Abs(y);
-            return (ax > ay) || float.IsNaN(ax) || (ax == ay && *(int*)&x >= 0) ? x : y;
-        }
-
-        private static unsafe float MathFMinMagnitude(float x, float y)
+        protected T NextRandom(T avoid)
         {
-            float ax = MathF.Abs(x), ay = MathF.Abs(y);
-            return (ax < ay) || float.IsNaN(ax) || (ax == ay && *(int*)&x < 0) ? x : y;
-        }
-
-        private static unsafe float UInt32ToSingle(uint i) => *(float*)&i;
-
-        private static unsafe float SingleToUInt32(float f) => *(uint*)&f;
-
-        /// <summary>Gets a variety of special values (e.g. NaN).</summary>
-        private static IEnumerable<float> GetSpecialValues()
-        {
-            // NaN
-            yield return UInt32ToSingle(0xFFC0_0000); // -qNaN / float.NaN
-            yield return UInt32ToSingle(0xFFFF_FFFF); // -qNaN / all-bits-set
-            yield return UInt32ToSingle(0x7FC0_0000); // +qNaN
-            yield return UInt32ToSingle(0xFFA0_0000); // -sNaN
-            yield return UInt32ToSingle(0x7FA0_0000); // +sNaN
-
-            // +Infinity, -Infinity
-            yield return float.PositiveInfinity;
-            yield return float.NegativeInfinity;
-
-            // +Zero, -Zero
-            yield return +0.0f;
-            yield return -0.0f;
-
-            // Subnormals
-            yield return +float.Epsilon;
-            yield return -float.Epsilon;
-            yield return UInt32ToSingle(0x007F_FFFF);
-            yield return UInt32ToSingle(0x807F_FFFF);
-
-            // Normals
-            yield return UInt32ToSingle(0x0080_0000);
-            yield return UInt32ToSingle(0x8080_0000);
-            yield return UInt32ToSingle(0x7F7F_FFFF); // MaxValue
-            yield return UInt32ToSingle(0xFF7F_FFFF); // MinValue
+            while (true)
+            {
+                T value = NextRandom();
+                if (!value.Equals(avoid))
+                {
+                    return value;
+                }
+            }
         }
 
         /// <summary>
@@ -118,12 +148,12 @@ private static IEnumerable<float> GetSpecialValues()
         /// the value is stored into a random position in <paramref name="x"/>, and the original
         /// value is subsequently restored.
         /// </summary>
-        private static void RunForEachSpecialValue(Action action, BoundedMemory<float> x)
+        protected void RunForEachSpecialValue(Action action, BoundedMemory<T> x)
         {
-            foreach (float value in GetSpecialValues())
+            foreach (T value in GetSpecialValues())
             {
-                int pos = s_random.Next(x.Length);
-                float orig = x[pos];
+                int pos = Random.Next(x.Length);
+                T orig = x[pos];
                 x[pos] = value;
 
                 action();
@@ -131,2861 +161,2881 @@ private static void RunForEachSpecialValue(Action action, BoundedMemory<float> x
                 x[pos] = orig;
             }
         }
-
-        /// <summary>
-        /// Loads a variety of special values (e.g. NaN) into random positions in <paramref name="x"/>
-        /// and related values into the corresponding positions in <paramref name="y"/>.
-        /// </summary>
-        private static void SetSpecialValues(Span<float> x, Span<float> y)
-        {
-            int pos;
-
-            // NaNs
-            pos = s_random.Next(x.Length);
-            x[pos] = float.NaN;
-            y[pos] = UInt32ToSingle(0x7FC0_0000);
-
-            // +Infinity, -Infinity
-            pos = s_random.Next(x.Length);
-            x[pos] = float.PositiveInfinity;
-            y[pos] = float.NegativeInfinity;
-
-            // +Zero, -Zero
-            pos = s_random.Next(x.Length);
-            x[pos] = +0.0f;
-            y[pos] = -0.0f;
-
-            // +Epsilon, -Epsilon
-            pos = s_random.Next(x.Length);
-            x[pos] = +float.Epsilon;
-            y[pos] = -float.Epsilon;
-
-            // Same magnitude, opposite sign
-            pos = s_random.Next(x.Length);
-            x[pos] = +5.0f;
-            y[pos] = -5.0f;
-        }
         #endregion
 
         #region Abs
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Abs(int tensorLength)
+        [Fact]
+        public void Abs_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                FillTensor(x, MinValue);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Abs(x, destination);
+                Abs(x, destination);
 
-            for (int i = 0; i < x.Length; i++)
-            {
-                AssertEqualTolerance(MathF.Abs(x[i]), destination[i]);
-            }
+                for (int i = 0; i < x.Length; i++)
+                {
+                    AssertEqualTolerance(Abs(x[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Abs_InPlace(int tensorLength)
+        [Fact]
+        public void Abs_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                FillTensor(x, MinValue);
+                T[] xOrig = x.Span.ToArray();
 
-            TensorPrimitives.Abs(x, x);
+                Abs(x, x);
 
-            for (int i = 0; i < x.Length; i++)
-            {
-                AssertEqualTolerance(MathF.Abs(xOrig[i]), x[i]);
-            }
+                for (int i = 0; i < x.Length; i++)
+                {
+                    AssertEqualTolerance(Abs(xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Abs_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Abs_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Abs(x, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Abs(x, destination));
+            });
         }
 
         [Fact]
-        public static void Abs_ThrowsForOverlapppingInputsWithOutputs()
+        public void Abs_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Abs(array.AsSpan(1, 5), array.AsSpan(0, 5)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Abs(array.AsSpan(1, 5), array.AsSpan(2, 5)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Abs(array.AsSpan(1, 5), array.AsSpan(0, 5)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Abs(array.AsSpan(1, 5), array.AsSpan(2, 5)));
         }
         #endregion
 
         #region Add
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Add_TwoTensors(int tensorLength)
+        [Fact]
+        public void Add_TwoTensors()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
-
-            TensorPrimitives.Add(x, y, destination);
-            for (int i = 0; i < tensorLength; i++)
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                AssertEqualTolerance(x[i] + y[i], destination[i]);
-            }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            float[] xOrig = x.Span.ToArray();
+                Add(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Add(x[i], y[i]), destination[i]);
+                }
 
-            // Validate that the destination can be the same as an input.
-            TensorPrimitives.Add(x, x, x);
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(xOrig[i] + xOrig[i], x[i]);
-            }
+                T[] xOrig = x.Span.ToArray();
+
+                // Validate that the destination can be the same as an input.
+                Add(x, x, x);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Add(xOrig[i], xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Add_TwoTensors_InPlace(int tensorLength)
+        [Fact]
+        public void Add_TwoTensors_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
 
-            TensorPrimitives.Add(x, x, x);
+                Add(x, x, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(xOrig[i] + xOrig[i], x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Add(xOrig[i], xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Add_TwoTensors_ThrowsForMismatchedLengths(int tensorLength)
+        [Fact]
+        public void Add_TwoTensors_ThrowsForMismatchedLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Add(x, y, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Add(y, x, destination));
+                Assert.Throws<ArgumentException>(() => Add(x, y, destination));
+                Assert.Throws<ArgumentException>(() => Add(y, x, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Add_TwoTensors_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Add_TwoTensors_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Add(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Add(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void Add_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
+        public void Add_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Add(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Add(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Add(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(4, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Add(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(6, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Add(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Add(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Add(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(4, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Add(array.AsSpan(1, 2), array.AsSpan(5, 2), array.AsSpan(6, 2)));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Add_TensorScalar(int tensorLength)
+        [Fact]
+        public void Add_TensorScalar()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Add(x, y, destination);
+                Add(x, y, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(x[i] + y, destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Add(x[i], y), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Add_TensorScalar_InPlace(int tensorLength)
+        [Fact]
+        public void Add_TensorScalar_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
-            float y = NextSingle();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                T y = NextRandom();
 
-            TensorPrimitives.Add(x, y, x);
+                Add(x, y, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(xOrig[i] + y, x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Add(xOrig[i], y), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Add_TensorScalar_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Add_TensorScalar_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Add(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Add(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void Add_TensorScalar_ThrowsForOverlapppingInputsWithOutputs()
+        public void Add_TensorScalar_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Add(array.AsSpan(1, 2), 42, array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Add(array.AsSpan(1, 2), 42, array.AsSpan(2, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Add(array.AsSpan(1, 2), default(T), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Add(array.AsSpan(1, 2), default(T), array.AsSpan(2, 2)));
         }
         #endregion
 
         #region AddMultiply
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void AddMultiply_ThreeTensors(int tensorLength)
+        [Fact]
+        public void AddMultiply_ThreeTensors()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> multiplier = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> multiplier = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.AddMultiply(x, y, multiplier, destination);
+                AddMultiply(x, y, multiplier, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((x[i] + y[i]) * multiplier[i], destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(AddMultiply(x[i], y[i], multiplier[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void AddMultiply_ThreeTensors_InPlace(int tensorLength)
+        [Fact]
+        public void AddMultiply_ThreeTensors_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
 
-            TensorPrimitives.AddMultiply(x, x, x, x);
+                AddMultiply(x, x, x, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((xOrig[i] + xOrig[i]) * xOrig[i], x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(AddMultiply(xOrig[i], xOrig[i], xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void AddMultiply_ThreeTensors_ThrowsForMismatchedLengths(int tensorLength)
+        [Fact]
+        public void AddMultiply_ThreeTensors_ThrowsForMismatchedLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> z = CreateAndFillTensor(tensorLength - 1);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> z = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(x, y, z, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(x, z, y, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(z, x, y, destination));
+                Assert.Throws<ArgumentException>(() => AddMultiply(x, y, z, destination));
+                Assert.Throws<ArgumentException>(() => AddMultiply(x, z, y, destination));
+                Assert.Throws<ArgumentException>(() => AddMultiply(z, x, y, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void AddMultiply_ThreeTensors_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void AddMultiply_ThreeTensors_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> multiplier = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> multiplier = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(x, y, multiplier, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(x, y, multiplier, destination));
+            });
         }
 
         [Fact]
-        public static void AddMultiply_ThreeTensors_ThrowsForOverlapppingInputsWithOutputs()
+        public void AddMultiply_ThreeTensors_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(5, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(6, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(8, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(5, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(6, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(8, 2)));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void AddMultiply_TensorTensorScalar(int tensorLength)
+        [Fact]
+        public void AddMultiply_TensorTensorScalar()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            float multiplier = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                T multiplier = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.AddMultiply(x, y, multiplier, destination);
+                AddMultiply(x, y, multiplier, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((x[i] + y[i]) * multiplier, destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(AddMultiply(x[i], y[i], multiplier), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void AddMultiply_TensorTensorScalar_InPlace(int tensorLength)
+        [Fact]
+        public void AddMultiply_TensorTensorScalar_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
-            float multiplier = NextSingle();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                T multiplier = NextRandom();
 
-            TensorPrimitives.AddMultiply(x, x, multiplier, x);
+                AddMultiply(x, x, multiplier, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((xOrig[i] + xOrig[i]) * multiplier, x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(AddMultiply(xOrig[i], xOrig[i], multiplier), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void AddMultiply_TensorTensorScalar_ThrowsForMismatchedLengths_x_y(int tensorLength)
+        [Fact]
+        public void AddMultiply_TensorTensorScalar_ThrowsForMismatchedLengths_x_y()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
-            float multiplier = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                T multiplier = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(x, y, multiplier, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(y, x, multiplier, destination));
+                Assert.Throws<ArgumentException>(() => AddMultiply(x, y, multiplier, destination));
+                Assert.Throws<ArgumentException>(() => AddMultiply(y, x, multiplier, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void AddMultiply_TensorTensorScalar_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void AddMultiply_TensorTensorScalar_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            float multiplier = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                T multiplier = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(x, y, multiplier, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(x, y, multiplier, destination));
+            });
         }
 
         [Fact]
-        public static void AddMultiply_TensorTensorScalar_ThrowsForOverlapppingInputsWithOutputs()
+        public void AddMultiply_TensorTensorScalar_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), 42, array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), 42, array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), 42, array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), 42, array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), default(T), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), default(T), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), default(T), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), array.AsSpan(4, 2), default(T), array.AsSpan(5, 2)));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void AddMultiply_TensorScalarTensor(int tensorLength)
+        [Fact]
+        public void AddMultiply_TensorScalarTensor()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> multiplier = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> multiplier = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.AddMultiply(x, y, multiplier, destination);
+                AddMultiply(x, y, multiplier, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((x[i] + y) * multiplier[i], destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(AddMultiply(x[i], y, multiplier[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void AddMultiply_TensorScalarTensor_InPlace(int tensorLength)
+        [Fact]
+        public void AddMultiply_TensorScalarTensor_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
-            float y = NextSingle();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                T y = NextRandom();
 
-            TensorPrimitives.AddMultiply(x, y, x, x);
+                AddMultiply(x, y, x, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((xOrig[i] + y) * xOrig[i], x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(AddMultiply(xOrig[i], y, xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void AddMultiply_TensorScalarTensor_ThrowsForMismatchedLengths_x_z(int tensorLength)
+        [Fact]
+        public void AddMultiply_TensorScalarTensor_ThrowsForMismatchedLengths_x_z()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> z = CreateAndFillTensor(tensorLength - 1);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> z = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(x, y, z, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(z, y, x, destination));
+                Assert.Throws<ArgumentException>(() => AddMultiply(x, y, z, destination));
+                Assert.Throws<ArgumentException>(() => AddMultiply(z, y, x, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void AddMultiply_TensorScalarTensor_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void AddMultiply_TensorScalarTensor_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> multiplier = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> multiplier = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(x, y, multiplier, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(x, y, multiplier, destination));
+            });
         }
 
         [Fact]
-        public static void AddMultiply_TensorScalarTensor_ThrowsForOverlapppingInputsWithOutputs()
+        public void AddMultiply_TensorScalarTensor_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), 42, array.AsSpan(4, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), 42, array.AsSpan(4, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), 42, array.AsSpan(4, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.AddMultiply(array.AsSpan(1, 2), 42, array.AsSpan(4, 2), array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), default(T), array.AsSpan(4, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), default(T), array.AsSpan(4, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), default(T), array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => AddMultiply(array.AsSpan(1, 2), default(T), array.AsSpan(4, 2), array.AsSpan(5, 2)));
         }
         #endregion
 
         #region Cosh
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Cosh(int tensorLength)
+        [Fact]
+        public void Cosh_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
-
-            TensorPrimitives.Cosh(x, destination);
+            if (!IsFloatingPoint) return;
 
-            for (int i = 0; i < tensorLength; i++)
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                AssertEqualTolerance(MathF.Cosh(x[i]), destination[i]);
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Cosh_InPlace(int tensorLength)
-        {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Cosh(x, x);
+                Cosh(x, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Cosh(xOrig[i]), x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Cosh(x[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Cosh_SpecialValues(int tensorLength)
+        [Fact]
+        public void Cosh_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            RunForEachSpecialValue(() =>
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                TensorPrimitives.Cosh(x, destination);
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+
+                Cosh(x, x);
+
                 for (int i = 0; i < tensorLength; i++)
                 {
-                    AssertEqualTolerance(MathF.Cosh(x[i]), destination[i]);
+                    AssertEqualTolerance(Cosh(xOrig[i]), x[i]);
                 }
-            }, x);
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(VectorLengthAndIteratedRange), new object[] { -100f, 100f, 3f })]
-        public static void Cosh_ValueRange(int vectorLength, float element)
+        [Fact]
+        public void Cosh_SpecialValues()
         {
-            float[] x = new float[vectorLength];
-            float[] dest = new float[vectorLength];
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                RunForEachSpecialValue(() =>
+                {
+                    Cosh(x, destination);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(Cosh(x[i]), destination[i]);
+                    }
+                }, x);
+            });
+        }
 
-            x.AsSpan().Fill(element);
-            TensorPrimitives.Cosh(x, dest);
+        [Fact]
+        public void Cosh_ValueRange()
+        {
+            if (!IsFloatingPoint) return;
 
-            float expected = MathF.Cosh(element);
-            foreach (float actual in dest)
+            Assert.All(VectorLengthAndIteratedRange(ConvertFromSingle(-100f), ConvertFromSingle(100f), ConvertFromSingle(3f)), arg =>
             {
-                AssertEqualTolerance(expected, actual);
-            }
+                T[] x = new T[arg.Length];
+                T[] dest = new T[arg.Length];
+
+                x.AsSpan().Fill(arg.Element);
+                Cosh(x, dest);
+
+                T expected = Cosh(arg.Element);
+                foreach (T actual in dest)
+                {
+                    AssertEqualTolerance(expected, actual);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Cosh_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Cosh_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Cosh(x, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Cosh(x, destination));
+            });
         }
 
         [Fact]
-        public static void Cosh_ThrowsForOverlapppingInputsWithOutputs()
+        public void Cosh_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Cosh(array.AsSpan(1, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Cosh(array.AsSpan(1, 2), array.AsSpan(2, 2)));
+            if (!IsFloatingPoint) return;
+
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Cosh(array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Cosh(array.AsSpan(1, 2), array.AsSpan(2, 2)));
         }
         #endregion
 
         #region CosineSimilarity
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void CosineSimilarity_ThrowsForMismatchedLengths(int tensorLength)
+        [Fact]
+        public void CosineSimilarity_ThrowsForMismatchedLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.CosineSimilarity(x, y));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.CosineSimilarity(y, x));
+                Assert.Throws<ArgumentException>(() => CosineSimilarity(x, y));
+                Assert.Throws<ArgumentException>(() => CosineSimilarity(y, x));
+            });
         }
 
         [Fact]
-        public static void CosineSimilarity_ThrowsForEmpty()
+        public void CosineSimilarity_ThrowsForEmpty()
         {
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.CosineSimilarity(ReadOnlySpan<float>.Empty, ReadOnlySpan<float>.Empty));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.CosineSimilarity(ReadOnlySpan<float>.Empty, CreateTensor(1)));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.CosineSimilarity(CreateTensor(1), ReadOnlySpan<float>.Empty));
-        }
+            if (!IsFloatingPoint) return;
 
-        [Theory]
-        [InlineData(new float[] { 3, 2, 0, 5 }, new float[] { 1, 0, 0, 0 }, 0.48666f)]
-        [InlineData(new float[] { 1, 1, 1, 1, 1, 0 }, new float[] { 1, 1, 1, 1, 0, 1 }, 0.80f)]
-        public static void CosineSimilarity_KnownValues(float[] x, float[] y, float expectedResult)
-        {
-            AssertEqualTolerance(expectedResult, TensorPrimitives.CosineSimilarity(x, y));
+            Assert.Throws<ArgumentException>(() => CosineSimilarity(ReadOnlySpan<T>.Empty, ReadOnlySpan<T>.Empty));
+            Assert.Throws<ArgumentException>(() => CosineSimilarity(ReadOnlySpan<T>.Empty, CreateTensor(1)));
+            Assert.Throws<ArgumentException>(() => CosineSimilarity(CreateTensor(1), ReadOnlySpan<T>.Empty));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void CosineSimilarity(int tensorLength)
+        [Fact]
+        public void CosineSimilarity_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            float dot = 0f, squareX = 0f, squareY = 0f;
-            for (int i = 0; i < x.Length; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                dot += x[i] * y[i];
-                squareX += x[i] * x[i];
-                squareY += y[i] * y[i];
-            }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+
+                T dot = default, squareX = default, squareY = default;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    dot = Add(dot, Multiply(x[i], y[i]));
+                    squareX = Add(squareX, Multiply(x[i], x[i]));
+                    squareY = Add(squareY, Multiply(y[i], y[i]));
+                }
 
-            AssertEqualTolerance(dot / (MathF.Sqrt(squareX) * MathF.Sqrt(squareY)), TensorPrimitives.CosineSimilarity(x, y));
+                AssertEqualTolerance(Divide(dot, Multiply(Sqrt(squareX), Sqrt(squareY))), CosineSimilarity(x, y));
+            });
         }
         #endregion
 
         #region Distance
         [Fact]
-        public static void Distance_ThrowsForEmpty()
+        public void Distance_ThrowsForEmpty()
         {
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Distance(ReadOnlySpan<float>.Empty, ReadOnlySpan<float>.Empty));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Distance(ReadOnlySpan<float>.Empty, CreateTensor(1)));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Distance(CreateTensor(1), ReadOnlySpan<float>.Empty));
+            if (!IsFloatingPoint) return;
+
+            Assert.Throws<ArgumentException>(() => Distance(ReadOnlySpan<T>.Empty, ReadOnlySpan<T>.Empty));
+            Assert.Throws<ArgumentException>(() => Distance(ReadOnlySpan<T>.Empty, CreateTensor(1)));
+            Assert.Throws<ArgumentException>(() => Distance(CreateTensor(1), ReadOnlySpan<T>.Empty));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Distance_ThrowsForMismatchedLengths(int tensorLength)
+        [Fact]
+        public void Distance_ThrowsForMismatchedLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
+            if (!IsFloatingPoint) return;
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Distance(x, y));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Distance(y, x));
-        }
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
 
-        [Theory]
-        [InlineData(new float[] { 3, 2 }, new float[] { 4, 1 }, 1.4142f)]
-        [InlineData(new float[] { 0, 4 }, new float[] { 6, 2 }, 6.3245f)]
-        [InlineData(new float[] { 1, 2, 3 }, new float[] { 4, 5, 6 }, 5.19615f)]
-        [InlineData(new float[] { 5, 1, 6, 10 }, new float[] { 7, 2, 8, 4 }, 6.7082f)]
-        public static void Distance_KnownValues(float[] x, float[] y, float expectedResult)
-        {
-            AssertEqualTolerance(expectedResult, TensorPrimitives.Distance(x, y));
+                Assert.Throws<ArgumentException>(() => Distance(x, y));
+                Assert.Throws<ArgumentException>(() => Distance(y, x));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Distance(int tensorLength)
+        [Fact]
+        public void Distance_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            float distance = 0f;
-            for (int i = 0; i < x.Length; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                distance += (x[i] - y[i]) * (x[i] - y[i]);
-            }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+
+                T distance = default;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    distance = Add(distance, Multiply(Subtract(x[i], y[i]), Subtract(x[i], y[i])));
+                }
 
-            AssertEqualTolerance(MathF.Sqrt(distance), TensorPrimitives.Distance(x, y));
+                AssertEqualTolerance(Sqrt(distance), Distance(x, y));
+            });
         }
         #endregion
 
         #region Divide
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Divide_TwoTensors(int tensorLength)
+        [Fact]
+        public void Divide_TwoTensors()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateTensor(tensorLength);
+                FillTensor(y, Zero);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Divide(x, y, destination);
+                Divide(x, y, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(x[i] / y[i], destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Divide(x[i], y[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Divide_TwoTensors_InPlace(int tensorLength)
+        [Fact]
+        public void Divide_TwoTensors_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                FillTensor(x, Zero);
+                T[] xOrig = x.Span.ToArray();
 
-            TensorPrimitives.Divide(x, x, x);
+                Divide(x, x, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(xOrig[i] / xOrig[i], x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Divide(xOrig[i], xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Divide_TwoTensors_ThrowsForMismatchedLengths(int tensorLength)
+        [Fact]
+        public void Divide_TwoTensors_ThrowsForMismatchedLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Divide(x, y, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Divide(y, x, destination));
+                Assert.Throws<ArgumentException>(() => Divide(x, y, destination));
+                Assert.Throws<ArgumentException>(() => Divide(y, x, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Divide_TwoTensors_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Divide_TwoTensors_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Divide(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Divide(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void Divide_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
+        public void Divide_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Divide_TensorScalar(int tensorLength)
+        [Fact]
+        public void Divide_TensorScalar()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom(default);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Divide(x, y, destination);
+                Divide(x, y, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(x[i] / y, destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Divide(x[i], y), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Divide_TensorScalar_InPlace(int tensorLength)
+        [Fact]
+        public void Divide_TensorScalar_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
-            float y = NextSingle();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                T y = NextRandom(default);
 
-            TensorPrimitives.Divide(x, y, x);
+                Divide(x, y, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(xOrig[i] / y, x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Divide(xOrig[i], y), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Divide_TensorScalar_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Divide_TensorScalar_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Divide(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Divide(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void Divide_TensorScalar_ThrowsForOverlapppingInputsWithOutputs()
+        public void Divide_TensorScalar_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Divide(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
         }
         #endregion
 
         #region Dot
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Dot_ThrowsForMismatchedLengths_x_y(int tensorLength)
+        [Fact]
+        public void Dot_ThrowsForMismatchedLengths_x_y()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
-
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Dot(x, y));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Dot(y, x));
-        }
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
 
-        [Theory]
-        [InlineData(new float[] { 1, 3, -5 }, new float[] { 4, -2, -1 }, 3)]
-        [InlineData(new float[] { 1, 2, 3 }, new float[] { 4, 5, 6 }, 32)]
-        [InlineData(new float[] { 1, 2, 3, 10, 8 }, new float[] { 4, 5, 6, -2, 7 }, 68)]
-        [InlineData(new float[] { }, new float[] { }, 0)]
-        public static void Dot_KnownValues(float[] x, float[] y, float expectedResult)
-        {
-            AssertEqualTolerance(expectedResult, TensorPrimitives.Dot(x, y));
+                Assert.Throws<ArgumentException>(() => Dot(x, y));
+                Assert.Throws<ArgumentException>(() => Dot(y, x));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Dot(int tensorLength)
+        [Fact]
+        public void Dot_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-
-            float dot = 0f;
-            for (int i = 0; i < x.Length; i++)
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                dot += x[i] * y[i];
-            }
-
-            AssertEqualTolerance(dot, TensorPrimitives.Dot(x, y));
-        }
-        #endregion
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
 
-        #region Exp
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Exp(int tensorLength)
-        {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
-
-            TensorPrimitives.Exp(x, destination);
+                T dot = default;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    dot = Add(dot, Multiply(x[i], y[i]));
+                }
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Exp(x[i]), destination[i]);
-            }
+                AssertEqualTolerance(dot, Dot(x, y));
+            });
         }
+        #endregion
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Exp_InPlace(int tensorLength)
+        #region Exp
+        [Fact]
+        public void Exp_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
-
-            TensorPrimitives.Exp(x, x);
+            if (!IsFloatingPoint) return;
 
-            for (int i = 0; i < tensorLength; i++)
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                AssertEqualTolerance(MathF.Exp(xOrig[i]), x[i]);
-            }
-        }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Exp_SpecialValues(int tensorLength)
-        {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+                Exp(x, destination);
 
-            RunForEachSpecialValue(() =>
-            {
-                TensorPrimitives.Exp(x, destination);
                 for (int i = 0; i < tensorLength; i++)
                 {
-                    AssertEqualTolerance(MathF.Exp(x[i]), destination[i]);
+                    AssertEqualTolerance(Exp(x[i]), destination[i]);
                 }
-            }, x);
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Exp_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Exp_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            if (!IsFloatingPoint) return;
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Exp(x, destination));
-        }
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
 
-        [Fact]
-        public static void Exp_ThrowsForOverlapppingInputsWithOutputs()
-        {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Exp(array.AsSpan(1, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Exp(array.AsSpan(1, 2), array.AsSpan(2, 2)));
-        }
-        #endregion
+                Exp(x, x);
 
-        #region IndexOfMax
-        [Fact]
-        public static void IndexOfMax_ReturnsNegative1OnEmpty()
-        {
-            Assert.Equal(-1, TensorPrimitives.IndexOfMax(ReadOnlySpan<float>.Empty));
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Exp(xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void IndexOfMax(int tensorLength)
+        [Fact]
+        public void Exp_SpecialValues()
         {
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
-            {
-                using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                x[expected] = Enumerable.Max(MemoryMarshal.ToEnumerable<float>(x.Memory)) + 1;
-                Assert.Equal(expected, TensorPrimitives.IndexOfMax(x));
-            }
-        }
+            if (!IsFloatingPoint) return;
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void IndexOfMax_FirstNaNReturned(int tensorLength)
-        {
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                x[expected] = float.NaN;
-                x[tensorLength - 1] = float.NaN;
-                Assert.Equal(expected, TensorPrimitives.IndexOfMax(x));
-            }
-        }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-        [Fact]
-        public static void IndexOfMax_Negative0LesserThanPositive0()
-        {
-            Assert.Equal(1, TensorPrimitives.IndexOfMax([-0f, +0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMax([-0f, -0f, -0f, -0f]));
-            Assert.Equal(4, TensorPrimitives.IndexOfMax([-0f, -0f, -0f, -0f, +0f, +0f, +0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMax([+0f, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMax([-1, -0f]));
-            Assert.Equal(2, TensorPrimitives.IndexOfMax([-1, -0f, 1]));
+                RunForEachSpecialValue(() =>
+                {
+                    Exp(x, destination);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(Exp(x[i]), destination[i]);
+                    }
+                }, x);
+            });
         }
-        #endregion
 
-        #region IndexOfMaxMagnitude
         [Fact]
-        public static void IndexOfMaxMagnitude_ReturnsNegative1OnEmpty()
+        public void Exp_ThrowsForTooShortDestination()
         {
-            Assert.Equal(-1, TensorPrimitives.IndexOfMaxMagnitude(ReadOnlySpan<float>.Empty));
-        }
+            if (!IsFloatingPoint) return;
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void IndexOfMaxMagnitude(int tensorLength)
-        {
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                x[expected] = Enumerable.Max(MemoryMarshal.ToEnumerable<float>(x.Memory), Math.Abs) + 1;
-                Assert.Equal(expected, TensorPrimitives.IndexOfMaxMagnitude(x));
-            }
-        }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void IndexOfMaxMagnitude_FirstNaNReturned(int tensorLength)
-        {
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
-            {
-                using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                x[expected] = float.NaN;
-                x[tensorLength - 1] = float.NaN;
-                Assert.Equal(expected, TensorPrimitives.IndexOfMaxMagnitude(x));
-            }
+                AssertExtensions.Throws<ArgumentException>("destination", () => Exp(x, destination));
+            });
         }
 
         [Fact]
-        public static void IndexOfMaxMagnitude_Negative0LesserThanPositive0()
+        public void Exp_ThrowsForOverlapppingInputsWithOutputs()
         {
-            Assert.Equal(0, TensorPrimitives.IndexOfMaxMagnitude([-0f, -0f, -0f, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMaxMagnitude([-0f, +0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMaxMagnitude([-0f, +0f, +0f, +0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMaxMagnitude([+0f, -0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMaxMagnitude([-1, -0f]));
-            Assert.Equal(2, TensorPrimitives.IndexOfMaxMagnitude([-1, -0f, 1]));
+            if (!IsFloatingPoint) return;
+
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Exp(array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Exp(array.AsSpan(1, 2), array.AsSpan(2, 2)));
         }
         #endregion
 
-        #region IndexOfMin
+        #region Log
         [Fact]
-        public static void IndexOfMin_ReturnsNegative1OnEmpty()
+        public void Log_AllValues()
         {
-            Assert.Equal(-1, TensorPrimitives.IndexOfMin(ReadOnlySpan<float>.Empty));
-        }
+            if (!IsFloatingPoint) return;
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void IndexOfMin(int tensorLength)
-        {
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                x[expected] = Enumerable.Min(MemoryMarshal.ToEnumerable<float>(x.Memory)) - 1;
-                Assert.Equal(expected, TensorPrimitives.IndexOfMin(x));
-            }
-        }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void IndexOfMin_FirstNaNReturned(int tensorLength)
-        {
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
-            {
-                using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                x[expected] = float.NaN;
-                x[tensorLength - 1] = float.NaN;
-                Assert.Equal(expected, TensorPrimitives.IndexOfMin(x));
-            }
-        }
+                Log(x, destination);
 
-        [Fact]
-        public static void IndexOfMin_Negative0LesserThanPositive0()
-        {
-            Assert.Equal(0, TensorPrimitives.IndexOfMin([-0f, +0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMin([+0f, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMin([+0f, -0f, -0f, -0f, -0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMin([-1, -0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMin([-1, -0f, 1]));
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Log(x[i]), destination[i]);
+                }
+            });
         }
-        #endregion
 
-        #region IndexOfMinMagnitude
         [Fact]
-        public static void IndexOfMinMagnitude_ReturnsNegative1OnEmpty()
+        public void Log_InPlace()
         {
-            Assert.Equal(-1, TensorPrimitives.IndexOfMinMagnitude(ReadOnlySpan<float>.Empty));
-        }
+            if (!IsFloatingPoint) return;
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void IndexOfMinMagnitude(int tensorLength)
-        {
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                using BoundedMemory<float> x = CreateTensor(tensorLength);
-                for (int i = 0; i < x.Length; i++)
-                {
-                    x[i] = i % 2 == 0 ? 42 : -42;
-                }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
 
-                x[expected] = -41;
+                Log(x, x);
 
-                Assert.Equal(expected, TensorPrimitives.IndexOfMinMagnitude(x));
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Log(xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void IndexOfMinMagnitude_FirstNaNReturned(int tensorLength)
+        [Fact]
+        public void Log_SpecialValues()
         {
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-                x[expected] = float.NaN;
-                x[tensorLength - 1] = float.NaN;
-                Assert.Equal(expected, TensorPrimitives.IndexOfMinMagnitude(x));
-            }
-        }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-        [Fact]
-        public static void IndexOfMinMagnitude_Negative0LesserThanPositive0()
-        {
-            Assert.Equal(0, TensorPrimitives.IndexOfMinMagnitude([-0f, -0f, -0f, -0f]));
-            Assert.Equal(0, TensorPrimitives.IndexOfMinMagnitude([-0f, +0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([+0f, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([+0f, -0f, -0f, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([-1, -0f]));
-            Assert.Equal(1, TensorPrimitives.IndexOfMinMagnitude([-1, -0f, 1]));
+                RunForEachSpecialValue(() =>
+                {
+                    Log(x, destination);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(Log(x[i]), destination[i]);
+                    }
+                }, x);
+            });
         }
-        #endregion
 
-        #region Log
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Log(int tensorLength)
+        [Fact]
+        public void Log_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            TensorPrimitives.Log(x, destination);
-
-            for (int i = 0; i < tensorLength; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                AssertEqualTolerance(MathF.Log(x[i]), destination[i]);
-            }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => Log(x, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Log_InPlace(int tensorLength)
+        [Fact]
+        public void Log_ThrowsForOverlapppingInputsWithOutputs()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
-
-            TensorPrimitives.Log(x, x);
+            if (!IsFloatingPoint) return;
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Log(xOrig[i]), x[i]);
-            }
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Log(array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Log(array.AsSpan(1, 2), array.AsSpan(2, 2)));
         }
+        #endregion
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Log_SpecialValues(int tensorLength)
+        #region Log2
+        [Fact]
+        public void Log2_AllValues()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            RunForEachSpecialValue(() =>
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                TensorPrimitives.Log(x, destination);
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                Log2(x, destination);
+
                 for (int i = 0; i < tensorLength; i++)
                 {
-                    AssertEqualTolerance(MathF.Log(x[i]), destination[i]);
+                    AssertEqualTolerance(Log2(x[i]), destination[i]);
                 }
-            }, x);
-        }
-
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Log_ThrowsForTooShortDestination(int tensorLength)
-        {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
-
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Log(x, destination));
+            });
         }
 
         [Fact]
-        public static void Log_ThrowsForOverlapppingInputsWithOutputs()
-        {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Log(array.AsSpan(1, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Log(array.AsSpan(1, 2), array.AsSpan(2, 2)));
-        }
-        #endregion
-
-        #region Log2
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Log2(int tensorLength)
+        public void Log2_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
-
-            TensorPrimitives.Log2(x, destination);
+            if (!IsFloatingPoint) return;
 
-            for (int i = 0; i < tensorLength; i++)
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                AssertEqualTolerance(MathF.Log(x[i], 2), destination[i]);
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Log2_InPlace(int tensorLength)
-        {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
 
-            TensorPrimitives.Log2(x, x);
+                Log2(x, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Log(xOrig[i], 2), x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Log2(xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Log2_SpecialValues(int tensorLength)
+        [Fact]
+        public void Log2_SpecialValues()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            RunForEachSpecialValue(() =>
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                TensorPrimitives.Log2(x, destination);
-                for (int i = 0; i < tensorLength; i++)
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                RunForEachSpecialValue(() =>
                 {
-                    AssertEqualTolerance(MathF.Log(x[i], 2), destination[i]);
-                }
-            }, x);
+                    Log2(x, destination);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(Log2(x[i]), destination[i]);
+                    }
+                }, x);
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Log2_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Log2_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Log2(x, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Log2(x, destination));
+            });
         }
 
         [Fact]
-        public static void Log2_ThrowsForOverlapppingInputsWithOutputs()
+        public void Log2_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Log2(array.AsSpan(1, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Log2(array.AsSpan(1, 2), array.AsSpan(2, 2)));
+            if (!IsFloatingPoint) return;
+
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Log2(array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Log2(array.AsSpan(1, 2), array.AsSpan(2, 2)));
         }
         #endregion
 
         #region Max
         [Fact]
-        public static void Max_Tensor_ThrowsForEmpty()
+        public void Max_Tensor_ThrowsForEmpty()
         {
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Max(ReadOnlySpan<float>.Empty));
+            Assert.Throws<ArgumentException>(() => Max(ReadOnlySpan<T>.Empty));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Max_Tensor(int tensorLength)
+        [Fact]
+        public void Max_Tensor()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
 
-            Assert.Equal(Enumerable.Max(MemoryMarshal.ToEnumerable<float>(x.Memory)), TensorPrimitives.Max(x));
+                Assert.Equal(Enumerable.Max(MemoryMarshal.ToEnumerable<T>(x.Memory)), Max(x));
 
-            float max = float.NegativeInfinity;
-            foreach (float f in x.Span)
-            {
-                max = Math.Max(max, f);
-            }
+                T max = x.Span[0];
+                foreach (T f in x.Span)
+                {
+                    max = Max(max, f);
+                }
+
+                Assert.Equal(max, Max(x));
 
-            Assert.Equal(max, TensorPrimitives.Max(x));
-            Assert.Equal(SingleToUInt32(x[TensorPrimitives.IndexOfMax(x)]), SingleToUInt32(TensorPrimitives.Max(x)));
+                // TODO: Put a variant of this back once we have IndexOf routines
+                // Assert.Equal(SingleToUInt32(x[IndexOfMax(x)]), SingleToUInt32(Max(x)));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Max_Tensor_SpecialValues(int tensorLength)
+        [Fact]
+        public void Max_Tensor_SpecialValues()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-
-            RunForEachSpecialValue(() =>
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                float max = float.NegativeInfinity;
-                foreach (float f in x.Span)
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+
+                RunForEachSpecialValue(() =>
                 {
-                    max = Math.Max(max, f);
-                }
+                    T max = x.Span[0];
+                    foreach (T f in x.Span)
+                    {
+                        max = Max(max, f);
+                    }
 
-                Assert.Equal(max, TensorPrimitives.Max(x));
-                Assert.Equal(SingleToUInt32(x[TensorPrimitives.IndexOfMax(x)]), SingleToUInt32(TensorPrimitives.Max(x)));
-            }, x);
+                    Assert.Equal(max, Max(x));
+
+                    // TODO: Put a variant of this back once we have IndexOf routines
+                    // Assert.Equal(SingleToUInt32(x[IndexOfMax(x)]), SingleToUInt32(Max(x)));
+                }, x);
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Max_Tensor_NanReturned(int tensorLength)
+        [Fact]
+        public void Max_Tensor_NanReturned()
         {
-            using BoundedMemory<float> x = CreateTensor(tensorLength);
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                FillTensor(x);
-                x[expected] = float.NaN;
-                Assert.Equal(float.NaN, TensorPrimitives.Max(x));
-            }
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    FillTensor(x);
+                    x[expected] = NaN;
+                    Assert.Equal(NaN, Max(x));
+                }
+            });
         }
 
         [Fact]
-        public static void Max_Tensor_Negative0LesserThanPositive0()
+        public void Max_Tensor_Negative0LesserThanPositive0()
         {
-            Assert.Equal(+0f, TensorPrimitives.Max([-0f, +0f]));
-            Assert.Equal(+0f, TensorPrimitives.Max([+0f, -0f]));
-            Assert.Equal(-0f, TensorPrimitives.Max([-1, -0f]));
-            Assert.Equal(1, TensorPrimitives.Max([-1, -0f, 1]));
+            Assert.Equal(ConvertFromSingle(+0f), Max([ConvertFromSingle(-0f), ConvertFromSingle(+0f)]));
+            Assert.Equal(ConvertFromSingle(+0f), Max([ConvertFromSingle(+0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(ConvertFromSingle(-0f), Max([ConvertFromSingle(-1), ConvertFromSingle(-0f)]));
+            Assert.Equal(ConvertFromSingle(1), Max([ConvertFromSingle(-1), ConvertFromSingle(-0f), ConvertFromSingle(1)]));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Max_TwoTensors(int tensorLength)
+        [Fact]
+        public void Max_TwoTensors()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Max(x, y, destination);
+                Max(x, y, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Max(x[i], y[i]), destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Max(x[i], y[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Max_TwoTensors_InPlace(int tensorLength)
+        [Fact]
+        public void Max_TwoTensors_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray(), yOrig = y.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray(), yOrig = y.Span.ToArray();
 
-            TensorPrimitives.Max(x, y, x);
+                Max(x, y, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Max(xOrig[i], y[i]), x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Max(xOrig[i], y[i]), x[i]);
+                }
 
-            xOrig.AsSpan().CopyTo(x.Span);
-            yOrig.AsSpan().CopyTo(y.Span);
+                xOrig.AsSpan().CopyTo(x.Span);
+                yOrig.AsSpan().CopyTo(y.Span);
 
-            TensorPrimitives.Max(x, y, y);
+                Max(x, y, y);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Max(x[i], yOrig[i]), y[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Max(x[i], yOrig[i]), y[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Max_TwoTensors_SpecialValues(int tensorLength)
+        [Fact]
+        public void Max_TwoTensors_SpecialValues()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            SetSpecialValues(x, y);
+                SetSpecialValues(x, y);
 
-            TensorPrimitives.Max(x, y, destination);
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Max(x[i], y[i]), destination[i]);
-            }
+                Max(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Max(x[i], y[i]), destination[i]);
+                }
 
-            TensorPrimitives.Max(y, x, destination);
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Max(y[i], x[i]), destination[i]);
-            }
+                Max(y, x, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Max(y[i], x[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Max_TwoTensors_ThrowsForMismatchedLengths(int tensorLength)
+        [Fact]
+        public void Max_TwoTensors_ThrowsForMismatchedLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Max(x, y, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Max(y, x, destination));
+                Assert.Throws<ArgumentException>(() => Max(x, y, destination));
+                Assert.Throws<ArgumentException>(() => Max(y, x, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Max_TwoTensors_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Max_TwoTensors_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Max(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Max(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void Max_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
+        public void Max_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Max(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Max(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Max(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Max(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Max(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Max(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Max(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Max(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
         }
         #endregion
 
         #region MaxMagnitude
         [Fact]
-        public static void MaxMagnitude_Tensor_ThrowsForEmpty()
+        public void MaxMagnitude_Tensor_ThrowsForEmpty()
         {
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.MaxMagnitude(ReadOnlySpan<float>.Empty));
+            Assert.Throws<ArgumentException>(() => MaxMagnitude(ReadOnlySpan<T>.Empty));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MaxMagnitude_Tensor(int tensorLength)
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/96443", TestRuntimes.Mono)]
+        [Fact]
+        public void MaxMagnitude_Tensor()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-
-            float maxMagnitude = x[0];
-            foreach (float f in x.Span)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                maxMagnitude = MathFMaxMagnitude(maxMagnitude, f);
-            }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+
+                T maxMagnitude = x[0];
+                foreach (T f in x.Span)
+                {
+                    maxMagnitude = MaxMagnitude(maxMagnitude, f);
+                }
 
-            Assert.Equal(maxMagnitude, TensorPrimitives.MaxMagnitude(x));
-            Assert.Equal(SingleToUInt32(x[TensorPrimitives.IndexOfMaxMagnitude(x)]), SingleToUInt32(TensorPrimitives.MaxMagnitude(x)));
+                Assert.Equal(maxMagnitude, MaxMagnitude(x));
+
+                // TODO: Put a variant of this back once we have IndexOf routines
+                // Assert.Equal(SingleToUInt32(x[IndexOfMaxMagnitude(x)]), SingleToUInt32(MaxMagnitude(x)));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MaxMagnitude_Tensor_SpecialValues(int tensorLength)
+        [Fact]
+        public void MaxMagnitude_Tensor_SpecialValues()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-
-            RunForEachSpecialValue(() =>
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                float maxMagnitude = x[0];
-                foreach (float f in x.Span)
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+
+                RunForEachSpecialValue(() =>
                 {
-                    maxMagnitude = MathFMaxMagnitude(maxMagnitude, f);
-                }
+                    T maxMagnitude = x[0];
+                    foreach (T f in x.Span)
+                    {
+                        maxMagnitude = MaxMagnitude(maxMagnitude, f);
+                    }
+
+                    Assert.Equal(maxMagnitude, MaxMagnitude(x));
 
-                Assert.Equal(maxMagnitude, TensorPrimitives.MaxMagnitude(x));
-                Assert.Equal(SingleToUInt32(x[TensorPrimitives.IndexOfMaxMagnitude(x)]), SingleToUInt32(TensorPrimitives.MaxMagnitude(x)));
-            }, x);
+                    // TODO: Put a variant of this back once we have IndexOf routines
+                    // Assert.Equal(SingleToUInt32(x[IndexOfMaxMagnitude(x)]), SingleToUInt32(MaxMagnitude(x)));
+                }, x);
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MaxMagnitude_Tensor_NanReturned(int tensorLength)
+        [Fact]
+        public void MaxMagnitude_Tensor_NanReturned()
         {
-            using BoundedMemory<float> x = CreateTensor(tensorLength);
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                FillTensor(x);
-                x[expected] = float.NaN;
-                Assert.Equal(float.NaN, TensorPrimitives.MaxMagnitude(x));
-            }
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    FillTensor(x);
+                    x[expected] = ConvertFromSingle(float.NaN);
+                    Assert.Equal(ConvertFromSingle(float.NaN), MaxMagnitude(x));
+                }
+            });
         }
 
         [Fact]
-        public static void MaxMagnitude_Tensor_Negative0LesserThanPositive0()
+        public void MaxMagnitude_Tensor_Negative0LesserThanPositive0()
         {
-            Assert.Equal(+0f, TensorPrimitives.MaxMagnitude([-0f, +0f]));
-            Assert.Equal(+0f, TensorPrimitives.MaxMagnitude([+0f, -0f]));
-            Assert.Equal(-1, TensorPrimitives.MaxMagnitude([-1, -0f]));
-            Assert.Equal(1, TensorPrimitives.MaxMagnitude([-1, -0f, 1]));
-            Assert.Equal(0f, TensorPrimitives.MaxMagnitude([-0f, -0f, -0f, -0f, -0f, 0f]));
-            Assert.Equal(1, TensorPrimitives.MaxMagnitude([-0f, -0f, -0f, -0f, -1, -0f, 0f, 1]));
+            Assert.Equal(ConvertFromSingle(0), MaxMagnitude([ConvertFromSingle(-0f), ConvertFromSingle(+0f)]));
+            Assert.Equal(ConvertFromSingle(0), MaxMagnitude([ConvertFromSingle(+0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(ConvertFromSingle(-1), MaxMagnitude([ConvertFromSingle(-1), ConvertFromSingle(-0f)]));
+            Assert.Equal(ConvertFromSingle(1), MaxMagnitude([ConvertFromSingle(-1), ConvertFromSingle(-0f), ConvertFromSingle(1)]));
+            Assert.Equal(ConvertFromSingle(0), MaxMagnitude([ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(0f)]));
+            Assert.Equal(ConvertFromSingle(1), MaxMagnitude( [ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-0f), ConvertFromSingle(-1), ConvertFromSingle(-0f), ConvertFromSingle(0f), ConvertFromSingle(1)]));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void MaxMagnitude_TwoTensors(int tensorLength)
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/96443", TestRuntimes.Mono)]
+        [Fact]
+        public void MaxMagnitude_TwoTensors()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.MaxMagnitude(x, y, destination);
+                MaxMagnitude(x, y, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathFMaxMagnitude(x[i], y[i]), destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(MaxMagnitude(x[i], y[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void MaxMagnitude_TwoTensors_InPlace(int tensorLength)
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/96443", TestRuntimes.Mono)]
+        [Fact]
+        public void MaxMagnitude_TwoTensors_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray(), yOrig = y.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray(), yOrig = y.Span.ToArray();
 
-            TensorPrimitives.MaxMagnitude(x, y, x);
+                MaxMagnitude(x, y, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathFMaxMagnitude(xOrig[i], y[i]), x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(MaxMagnitude(xOrig[i], y[i]), x[i]);
+                }
 
-            xOrig.AsSpan().CopyTo(x.Span);
-            yOrig.AsSpan().CopyTo(y.Span);
+                xOrig.AsSpan().CopyTo(x.Span);
+                yOrig.AsSpan().CopyTo(y.Span);
 
-            TensorPrimitives.MaxMagnitude(x, y, y);
+                MaxMagnitude(x, y, y);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathFMaxMagnitude(x[i], yOrig[i]), y[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(MaxMagnitude(x[i], yOrig[i]), y[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MaxMagnitude_TwoTensors_SpecialValues(int tensorLength)
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/96443", TestRuntimes.Mono)]
+        [Fact]
+        public void MaxMagnitude_TwoTensors_SpecialValues()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            SetSpecialValues(x, y);
+                SetSpecialValues(x, y);
 
-            TensorPrimitives.MaxMagnitude(x, y, destination);
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathFMaxMagnitude(x[i], y[i]), destination[i]);
-            }
+                MaxMagnitude(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(MaxMagnitude(x[i], y[i]), destination[i]);
+                }
 
-            TensorPrimitives.MaxMagnitude(y, x, destination);
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathFMaxMagnitude(y[i], x[i]), destination[i]);
-            }
+                MaxMagnitude(y, x, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(MaxMagnitude(y[i], x[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MaxMagnitude_TwoTensors_ThrowsForMismatchedLengths(int tensorLength)
+        [Fact]
+        public void MaxMagnitude_TwoTensors_ThrowsForMismatchedLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.MaxMagnitude(x, y, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.MaxMagnitude(y, x, destination));
+                Assert.Throws<ArgumentException>(() => MaxMagnitude(x, y, destination));
+                Assert.Throws<ArgumentException>(() => MaxMagnitude(y, x, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MaxMagnitude_TwoTensors_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void MaxMagnitude_TwoTensors_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MaxMagnitude(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => MaxMagnitude(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void MaxMagnitude_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
+        public void MaxMagnitude_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MaxMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MaxMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MaxMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MaxMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => MaxMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MaxMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MaxMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MaxMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
         }
         #endregion
 
         #region Min
         [Fact]
-        public static void Min_Tensor_ThrowsForEmpty()
+        public void Min_Tensor_ThrowsForEmpty()
         {
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Min(ReadOnlySpan<float>.Empty));
+            Assert.Throws<ArgumentException>(() => Min(ReadOnlySpan<T>.Empty));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Min_Tensor(int tensorLength)
+        [Fact]
+        public void Min_Tensor()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
 
-            Assert.Equal(Enumerable.Min(MemoryMarshal.ToEnumerable<float>(x.Memory)), TensorPrimitives.Min(x));
+                Assert.Equal(Enumerable.Min(MemoryMarshal.ToEnumerable<T>(x.Memory)), Min(x));
 
-            float min = float.PositiveInfinity;
-            foreach (float f in x.Span)
-            {
-                min = Math.Min(min, f);
-            }
+                T min = ConvertFromSingle(float.PositiveInfinity);
+                foreach (T f in x.Span)
+                {
+                    min = Min(min, f);
+                }
+
+                Assert.Equal(min, Min(x));
 
-            Assert.Equal(min, TensorPrimitives.Min(x));
-            Assert.Equal(SingleToUInt32(x[TensorPrimitives.IndexOfMin(x)]), SingleToUInt32(TensorPrimitives.Min(x)));
+                // TODO: Put a variant of this back once we have IndexOf routines
+                // Assert.Equal(SingleToUInt32(x[IndexOfMin(x)]), SingleToUInt32(Min(x)));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Min_Tensor_SpecialValues(int tensorLength)
+        [Fact]
+        public void Min_Tensor_SpecialValues()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-
-            RunForEachSpecialValue(() =>
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                float min = float.PositiveInfinity;
-                foreach (float f in x.Span)
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+
+                RunForEachSpecialValue(() =>
                 {
-                    min = Math.Min(min, f);
-                }
+                    T min = ConvertFromSingle(float.PositiveInfinity);
+                    foreach (T f in x.Span)
+                    {
+                        min = Min(min, f);
+                    }
+
+                    Assert.Equal(min, Min(x));
 
-                Assert.Equal(min, TensorPrimitives.Min(x));
-                Assert.Equal(SingleToUInt32(x[TensorPrimitives.IndexOfMin(x)]), SingleToUInt32(TensorPrimitives.Min(x)));
-            }, x);
+                    // TODO: Put a variant of this back once we have IndexOf routines
+                    // Assert.Equal(SingleToUInt32(x[IndexOfMin(x)]), SingleToUInt32(Min(x)));
+                }, x);
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Min_Tensor_NanReturned(int tensorLength)
+        [Fact]
+        public void Min_Tensor_NanReturned()
         {
-            using BoundedMemory<float> x = CreateTensor(tensorLength);
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                FillTensor(x);
-                x[expected] = float.NaN;
-                Assert.Equal(float.NaN, TensorPrimitives.Min(x));
-            }
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    FillTensor(x);
+                    x[expected] = ConvertFromSingle(float.NaN);
+                    Assert.Equal(ConvertFromSingle(float.NaN), Min(x));
+                }
+            });
         }
 
         [Fact]
-        public static void Min_Tensor_Negative0LesserThanPositive0()
+        public void Min_Tensor_Negative0LesserThanPositive0()
         {
-            Assert.Equal(-0f, TensorPrimitives.Min([-0f, +0f]));
-            Assert.Equal(-0f, TensorPrimitives.Min([+0f, -0f]));
-            Assert.Equal(-1, TensorPrimitives.Min([-1, -0f]));
-            Assert.Equal(-1, TensorPrimitives.Min([-1, -0f, 1]));
+            Assert.Equal(ConvertFromSingle(-0f), Min([ConvertFromSingle(-0f), ConvertFromSingle(+0f)]));
+            Assert.Equal(ConvertFromSingle(-0f), Min([ConvertFromSingle(+0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(ConvertFromSingle(-1), Min([ConvertFromSingle(-1), ConvertFromSingle(-0f)]));
+            Assert.Equal(ConvertFromSingle(-1), Min([ConvertFromSingle(-1), ConvertFromSingle(-0f), ConvertFromSingle(1)]));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Min_TwoTensors(int tensorLength)
+        [Fact]
+        public void Min_TwoTensors()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Min(x, y, destination);
+                Min(x, y, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Min(x[i], y[i]), destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Min(x[i], y[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Min_TwoTensors_InPlace(int tensorLength)
+        [Fact]
+        public void Min_TwoTensors_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray(), yOrig = y.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray(), yOrig = y.Span.ToArray();
 
-            TensorPrimitives.Min(x, y, x);
+                Min(x, y, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Min(xOrig[i], y[i]), x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Min(xOrig[i], y[i]), x[i]);
+                }
 
-            xOrig.AsSpan().CopyTo(x.Span);
-            yOrig.AsSpan().CopyTo(y.Span);
+                xOrig.AsSpan().CopyTo(x.Span);
+                yOrig.AsSpan().CopyTo(y.Span);
 
-            TensorPrimitives.Min(x, y, y);
+                Min(x, y, y);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Min(x[i], yOrig[i]), y[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Min(x[i], yOrig[i]), y[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Min_TwoTensors_SpecialValues(int tensorLength)
+        [Fact]
+        public void Min_TwoTensors_SpecialValues()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            SetSpecialValues(x, y);
+                SetSpecialValues(x, y);
 
-            TensorPrimitives.Min(x, y, destination);
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Min(x[i], y[i]), destination[i]);
-            }
+                Min(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Min(x[i], y[i]), destination[i]);
+                }
 
-            TensorPrimitives.Min(y, x, destination);
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Min(y[i], x[i]), destination[i]);
-            }
+                Min(y, x, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Min(y[i], x[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Min_TwoTensors_ThrowsForMismatchedLengths(int tensorLength)
+        [Fact]
+        public void Min_TwoTensors_ThrowsForMismatchedLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Min(x, y, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Min(y, x, destination));
+                Assert.Throws<ArgumentException>(() => Min(x, y, destination));
+                Assert.Throws<ArgumentException>(() => Min(y, x, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Min_TwoTensors_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Min_TwoTensors_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Min(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Min(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void Min_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
+        public void Min_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Min(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Min(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Min(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Min(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Min(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Min(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Min(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Min(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
         }
         #endregion
 
         #region MinMagnitude
         [Fact]
-        public static void MinMagnitude_Tensor_ThrowsForEmpty()
+        public void MinMagnitude_Tensor_ThrowsForEmpty()
         {
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.MinMagnitude(ReadOnlySpan<float>.Empty));
+            Assert.Throws<ArgumentException>(() => MinMagnitude(ReadOnlySpan<T>.Empty));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MinMagnitude_Tensor(int tensorLength)
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/96443", TestRuntimes.Mono)]
+        [Fact]
+        public void MinMagnitude_Tensor()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-
-            float minMagnitude = x[0];
-            foreach (float f in x.Span)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                minMagnitude = MathFMinMagnitude(minMagnitude, f);
-            }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+
+                T minMagnitude = x[0];
+                foreach (T f in x.Span)
+                {
+                    minMagnitude = MinMagnitude(minMagnitude, f);
+                }
+
+                Assert.Equal(minMagnitude, MinMagnitude(x));
 
-            Assert.Equal(minMagnitude, TensorPrimitives.MinMagnitude(x));
-            Assert.Equal(SingleToUInt32(x[TensorPrimitives.IndexOfMinMagnitude(x)]), SingleToUInt32(TensorPrimitives.MinMagnitude(x)));
+                // TODO: Put a variant of this back once we have IndexOf routines
+                // Assert.Equal(SingleToUInt32(x[IndexOfMinMagnitude(x)]), SingleToUInt32(MinMagnitude(x)));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MinMagnitude_Tensor_SpecialValues(int tensorLength)
+        [Fact]
+        public void MinMagnitude_Tensor_SpecialValues()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-
-            RunForEachSpecialValue(() =>
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                float minMagnitude = x[0];
-                foreach (float f in x.Span)
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+
+                RunForEachSpecialValue(() =>
                 {
-                    minMagnitude = MathFMinMagnitude(minMagnitude, f);
-                }
+                    T minMagnitude = x[0];
+                    foreach (T f in x.Span)
+                    {
+                        minMagnitude = MinMagnitude(minMagnitude, f);
+                    }
+
+                    Assert.Equal(minMagnitude, MinMagnitude(x));
 
-                Assert.Equal(minMagnitude, TensorPrimitives.MinMagnitude(x));
-                Assert.Equal(SingleToUInt32(x[TensorPrimitives.IndexOfMinMagnitude(x)]), SingleToUInt32(TensorPrimitives.MinMagnitude(x)));
-            }, x);
+                    // TODO: Put a variant of this back once we have IndexOf routines
+                    // Assert.Equal(SingleToUInt32(x[IndexOfMinMagnitude(x)]), SingleToUInt32(MinMagnitude(x)));
+                }, x);
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MinMagnitude_Tensor_NanReturned(int tensorLength)
+        [Fact]
+        public void MinMagnitude_Tensor_NanReturned()
         {
-            using BoundedMemory<float> x = CreateTensor(tensorLength);
-            foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                FillTensor(x);
-                x[expected] = float.NaN;
-                Assert.Equal(float.NaN, TensorPrimitives.MinMagnitude(x));
-            }
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                foreach (int expected in new[] { 0, tensorLength / 2, tensorLength - 1 })
+                {
+                    FillTensor(x);
+                    x[expected] = ConvertFromSingle(float.NaN);
+                    Assert.Equal(ConvertFromSingle(float.NaN), MinMagnitude(x));
+                }
+            });
         }
 
         [Fact]
-        public static void MinMagnitude_Tensor_Negative0LesserThanPositive0()
+        public void MinMagnitude_Tensor_Negative0LesserThanPositive0()
         {
-            Assert.Equal(0, TensorPrimitives.MinMagnitude([-0f, +0f]));
-            Assert.Equal(0, TensorPrimitives.MinMagnitude([+0f, -0f]));
-            Assert.Equal(0, TensorPrimitives.MinMagnitude([-1, -0f]));
-            Assert.Equal(0, TensorPrimitives.MinMagnitude([-1, -0f, 1]));
+            Assert.Equal(ConvertFromSingle(0), MinMagnitude([ConvertFromSingle(-0f), ConvertFromSingle(+0f)]));
+            Assert.Equal(ConvertFromSingle(0), MinMagnitude([ConvertFromSingle(+0f), ConvertFromSingle(-0f)]));
+            Assert.Equal(ConvertFromSingle(0), MinMagnitude([ConvertFromSingle(-1), ConvertFromSingle(-0f)]));
+            Assert.Equal(ConvertFromSingle(0), MinMagnitude([ConvertFromSingle(-1), ConvertFromSingle(-0f), ConvertFromSingle(1)]));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void MinMagnitude_TwoTensors(int tensorLength)
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/96443", TestRuntimes.Mono)]
+        [Fact]
+        public void MinMagnitude_TwoTensors()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.MinMagnitude(x, y, destination);
+                MinMagnitude(x, y, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathFMinMagnitude(x[i], y[i]), destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(MinMagnitude(x[i], y[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void MinMagnitude_TwoTensors_InPlace(int tensorLength)
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/96443", TestRuntimes.Mono)]
+        [Fact]
+        public void MinMagnitude_TwoTensors_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray(), yOrig = y.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray(), yOrig = y.Span.ToArray();
 
-            TensorPrimitives.MinMagnitude(x, y, x);
+                MinMagnitude(x, y, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathFMinMagnitude(xOrig[i], y[i]), x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(MinMagnitude(xOrig[i], y[i]), x[i]);
+                }
 
-            xOrig.AsSpan().CopyTo(x.Span);
-            yOrig.AsSpan().CopyTo(y.Span);
+                xOrig.AsSpan().CopyTo(x.Span);
+                yOrig.AsSpan().CopyTo(y.Span);
 
-            TensorPrimitives.MinMagnitude(x, y, y);
+                MinMagnitude(x, y, y);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathFMinMagnitude(x[i], yOrig[i]), y[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(MinMagnitude(x[i], yOrig[i]), y[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MinMagnitude_TwoTensors_SpecialValues(int tensorLength)
+        [ActiveIssue("https://github.com/dotnet/runtime/issues/96443", TestRuntimes.Mono)]
+        [Fact]
+        public void MinMagnitude_TwoTensors_SpecialValues()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            SetSpecialValues(x, y);
+                SetSpecialValues(x, y);
 
-            TensorPrimitives.MinMagnitude(x, y, destination);
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathFMinMagnitude(x[i], y[i]), destination[i]);
-            }
+                MinMagnitude(x, y, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(MinMagnitude(x[i], y[i]), destination[i]);
+                }
 
-            TensorPrimitives.MinMagnitude(y, x, destination);
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathFMinMagnitude(y[i], x[i]), destination[i]);
-            }
+                MinMagnitude(y, x, destination);
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(MinMagnitude(y[i], x[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MinMagnitude_TwoTensors_ThrowsForMismatchedLengths(int tensorLength)
+        [Fact]
+        public void MinMagnitude_TwoTensors_ThrowsForMismatchedLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.MinMagnitude(x, y, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.MinMagnitude(y, x, destination));
+                Assert.Throws<ArgumentException>(() => MinMagnitude(x, y, destination));
+                Assert.Throws<ArgumentException>(() => MinMagnitude(y, x, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MinMagnitude_TwoTensors_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void MinMagnitude_TwoTensors_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MinMagnitude(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => MinMagnitude(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void MinMagnitude_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
+        public void MinMagnitude_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MinMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MinMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MinMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MinMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => MinMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MinMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MinMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MinMagnitude(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
         }
         #endregion
 
         #region Multiply
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Multiply_TwoTensors(int tensorLength)
+        [Fact]
+        public void Multiply_TwoTensors()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Multiply(x, y, destination);
+                Multiply(x, y, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(x[i] * y[i], destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Multiply(x[i], y[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Multiply_TwoTensors_InPlace(int tensorLength)
+        [Fact]
+        public void Multiply_TwoTensors_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
 
-            TensorPrimitives.Multiply(x, x, x);
+                Multiply(x, x, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(xOrig[i] * xOrig[i], x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Multiply(xOrig[i], xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Multiply_TwoTensors_ThrowsForMismatchedLengths(int tensorLength)
+        [Fact]
+        public void Multiply_TwoTensors_ThrowsForMismatchedLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Multiply(x, y, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Multiply(y, x, destination));
+                Assert.Throws<ArgumentException>(() => Multiply(x, y, destination));
+                Assert.Throws<ArgumentException>(() => Multiply(y, x, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Multiply_TwoTensors_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Multiply_TwoTensors_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Multiply(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Multiply(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void Multiply_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
+        public void Multiply_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Multiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Multiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Multiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Multiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Multiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Multiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Multiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Multiply(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Multiply_TensorScalar(int tensorLength)
+        [Fact]
+        public void Multiply_TensorScalar()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Multiply(x, y, destination);
+                Multiply(x, y, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(x[i] * y, destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Multiply(x[i], y), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Multiply_TensorScalar_InPlace(int tensorLength)
+        [Fact]
+        public void Multiply_TensorScalar_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
-            float y = NextSingle();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                T y = NextRandom();
 
-            TensorPrimitives.Multiply(x, y, x);
+                Multiply(x, y, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(xOrig[i] * y, x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Multiply(xOrig[i], y), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Multiply_TensorScalar_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Multiply_TensorScalar_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Multiply(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Multiply(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void Multiply_TensorScalar_ThrowsForOverlapppingInputsWithOutputs()
+        public void Multiply_TensorScalar_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Multiply(array.AsSpan(1, 2), 42, array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Multiply(array.AsSpan(1, 2), 42, array.AsSpan(2, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Multiply(array.AsSpan(1, 2), default(T), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Multiply(array.AsSpan(1, 2), default(T), array.AsSpan(2, 2)));
         }
         #endregion
 
         #region MultiplyAdd
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void MultiplyAdd_ThreeTensors(int tensorLength)
+        [Fact]
+        public void MultiplyAdd_ThreeTensors()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> addend = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> addend = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.MultiplyAdd(x, y, addend, destination);
+                MultiplyAdd(x, y, addend, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((x[i] * y[i]) + addend[i], destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Add(Multiply(x[i], y[i]), addend[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void MultiplyAdd_ThreeTensors_InPlace(int tensorLength)
+        [Fact]
+        public void MultiplyAdd_ThreeTensors_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
 
-            TensorPrimitives.MultiplyAdd(x, x, x, x);
+                MultiplyAdd(x, x, x, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((xOrig[i] * xOrig[i]) + xOrig[i], x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Add(Multiply(xOrig[i], xOrig[i]), xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MultiplyAdd_ThreeTensors_ThrowsForMismatchedLengths_x_y(int tensorLength)
+        [Fact]
+        public void MultiplyAdd_ThreeTensors_ThrowsForMismatchedLengths_x_y()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> z = CreateAndFillTensor(tensorLength - 1);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> z = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.MultiplyAdd(x, y, z, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.MultiplyAdd(x, z, y, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.MultiplyAdd(z, x, y, destination));
+                Assert.Throws<ArgumentException>(() => MultiplyAdd(x, y, z, destination));
+                Assert.Throws<ArgumentException>(() => MultiplyAdd(x, z, y, destination));
+                Assert.Throws<ArgumentException>(() => MultiplyAdd(z, x, y, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MultiplyAdd_ThreeTensors_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void MultiplyAdd_ThreeTensors_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> addend = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> addend = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(x, y, addend, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(x, y, addend, destination));
+            });
         }
 
         [Fact]
-        public static void MultiplyAdd_ThreeTensors_ThrowsForOverlapppingInputsWithOutputs()
+        public void MultiplyAdd_ThreeTensors_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(5, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(6, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(8, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(5, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(6, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(7, 2), array.AsSpan(8, 2)));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void MultiplyAdd_TensorTensorScalar(int tensorLength)
+        [Fact]
+        public void MultiplyAdd_TensorTensorScalar()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            float addend = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                T addend = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.MultiplyAdd(x, y, addend, destination);
+                MultiplyAdd(x, y, addend, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((x[i] * y[i]) + addend, destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Add(Multiply(x[i], y[i]), addend), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void MultiplyAdd_TensorTensorScalar_InPlace(int tensorLength)
+        [Fact]
+        public void MultiplyAdd_TensorTensorScalar_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
-            float addend = NextSingle();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                T addend = NextRandom();
 
-            TensorPrimitives.MultiplyAdd(x, x, addend, x);
+                MultiplyAdd(x, x, addend, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((xOrig[i] * xOrig[i]) + addend, x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Add(Multiply(xOrig[i], xOrig[i]), addend), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MultiplyAdd_TensorTensorScalar_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void MultiplyAdd_TensorTensorScalar_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            float addend = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                T addend = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(x, y, addend, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(x, y, addend, destination));
+            });
         }
 
         [Fact]
-        public static void MultiplyAdd_TensorTensorScalar_ThrowsForOverlapppingInputsWithOutputs()
+        public void MultiplyAdd_TensorTensorScalar_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), 42, array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), 42, array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), 42, array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), 42, array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), default(T), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), default(T), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), default(T), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), array.AsSpan(4, 2), default(T), array.AsSpan(5, 2)));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void MultiplyAdd_TensorScalarTensor(int tensorLength)
+        [Fact]
+        public void MultiplyAdd_TensorScalarTensor()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> addend = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> addend = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.MultiplyAdd(x, y, addend, destination);
+                MultiplyAdd(x, y, addend, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((x[i] * y) + addend[i], destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Add(Multiply(x[i], y), addend[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void MultiplyAdd_TensorScalarTensor_InPlace(int tensorLength)
+        [Fact]
+        public void MultiplyAdd_TensorScalarTensor_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
-            float y = NextSingle();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                T y = NextRandom();
 
-            TensorPrimitives.MultiplyAdd(x, y, x, x);
+                MultiplyAdd(x, y, x, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance((xOrig[i] * y) + xOrig[i], x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Add(Multiply(xOrig[i], y), xOrig[i]), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void MultiplyAdd_TensorScalarTensor_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void MultiplyAdd_TensorScalarTensor_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> addend = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> addend = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(x, y, addend, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(x, y, addend, destination));
+            });
         }
 
         [Fact]
-        public static void MultiplyAdd_TensorScalarTensor_ThrowsForOverlapppingInputsWithOutputs()
+        public void MultiplyAdd_TensorScalarTensor_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), 42, array.AsSpan(4, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), 42, array.AsSpan(4, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), 42, array.AsSpan(4, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.MultiplyAdd(array.AsSpan(1, 2), 42, array.AsSpan(4, 2), array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), default(T), array.AsSpan(4, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), default(T), array.AsSpan(4, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), default(T), array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => MultiplyAdd(array.AsSpan(1, 2), default(T), array.AsSpan(4, 2), array.AsSpan(5, 2)));
         }
         #endregion
 
         #region Negate
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Negate(int tensorLength)
+        [Fact]
+        public void Negate_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Negate(x, destination);
+                Negate(x, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(-x[i], destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Multiply(x[i], NegativeOne), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Negate_InPlace(int tensorLength)
+        [Fact]
+        public void Negate_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
 
-            TensorPrimitives.Negate(x, x);
+                Negate(x, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(-xOrig[i], x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Multiply(xOrig[i], NegativeOne), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Negate_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Negate_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Negate(x, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Negate(x, destination));
+            });
         }
 
         [Fact]
-        public static void Negate_ThrowsForOverlapppingInputsWithOutputs()
+        public void Negate_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Negate(array.AsSpan(1, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Negate(array.AsSpan(1, 2), array.AsSpan(2, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Negate(array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Negate(array.AsSpan(1, 2), array.AsSpan(2, 2)));
         }
         #endregion
 
         #region Norm
-        [Theory]
-        [InlineData(new float[] { 1, 2, 3 }, 3.7416575f)]
-        [InlineData(new float[] { 3, 4 }, 5)]
-        [InlineData(new float[] { 3 }, 3)]
-        [InlineData(new float[] { 3, 4, 1, 2 }, 5.477226)]
-        [InlineData(new float[] { }, 0f)]
-        public static void Norm_KnownValues(float[] x, float expectedResult)
-        {
-            AssertEqualTolerance(expectedResult, TensorPrimitives.Norm(x));
-        }
-
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Norm(int tensorLength)
+        [Fact]
+        public void Norm_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            float sumOfSquares = 0f;
-            for (int i = 0; i < x.Length; i++)
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                sumOfSquares += x[i] * x[i];
-            }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
 
-            AssertEqualTolerance(MathF.Sqrt(sumOfSquares), TensorPrimitives.Norm(x));
+                T sumOfSquares = Zero;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    sumOfSquares = Add(sumOfSquares, Multiply(x[i], x[i]));
+                }
+
+                AssertEqualTolerance(Sqrt(sumOfSquares), Norm(x));
+            });
         }
         #endregion
 
         #region Product
         [Fact]
-        public static void Product_ThrowsForEmpty()
+        public void Product_ThrowsForEmpty()
         {
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Product(ReadOnlySpan<float>.Empty));
+            Assert.Throws<ArgumentException>(() => Product(ReadOnlySpan<T>.Empty));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Product(int tensorLength)
+        [Fact]
+        public void Product_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-
-            float f = x[0];
-            for (int i = 1; i < x.Length; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                f *= x[i];
-            }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
 
-            AssertEqualTolerance(f, TensorPrimitives.Product(x));
-        }
+                T f = x[0];
+                for (int i = 1; i < x.Length; i++)
+                {
+                    f = Multiply(f, x[i]);
+                }
 
-        [Theory]
-        [InlineData(1, new float[] { 1 })]
-        [InlineData(-2, new float[] { 1, -2 })]
-        [InlineData(-6, new float[] { 1, -2, 3 })]
-        [InlineData(24, new float[] { 1, -2, 3, -4 })]
-        [InlineData(120, new float[] { 1, -2, 3, -4, 5 })]
-        [InlineData(-720, new float[] { 1, -2, 3, -4, 5, -6 })]
-        [InlineData(0, new float[] { 1, -2, 3, -4, 5, -6, 0 })]
-        [InlineData(0, new float[] { 0, 1, -2, 3, -4, 5, -6 })]
-        [InlineData(0, new float[] { 1, -2, 3, 0, -4, 5, -6 })]
-        [InlineData(float.NaN, new float[] { 1, -2, 3, float.NaN, -4, 5, -6 })]
-        public static void Product_KnownValues(float expected, float[] input)
-        {
-            Assert.Equal(expected, TensorPrimitives.Product(input));
+                AssertEqualTolerance(f, Product(x));
+            });
         }
         #endregion
 
         #region ProductOfDifferences
         [Fact]
-        public static void ProductOfDifferences_ThrowsForEmptyAndMismatchedLengths()
+        public void ProductOfDifferences_ThrowsForEmptyAndMismatchedLengths()
         {
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.ProductOfDifferences(ReadOnlySpan<float>.Empty, ReadOnlySpan<float>.Empty));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.ProductOfDifferences(ReadOnlySpan<float>.Empty, CreateTensor(1)));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.ProductOfDifferences(CreateTensor(1), ReadOnlySpan<float>.Empty));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.ProductOfDifferences(CreateTensor(44), CreateTensor(43)));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.ProductOfDifferences(CreateTensor(43), CreateTensor(44)));
+            Assert.Throws<ArgumentException>(() => ProductOfDifferences(ReadOnlySpan<T>.Empty, ReadOnlySpan<T>.Empty));
+            Assert.Throws<ArgumentException>(() => ProductOfDifferences(ReadOnlySpan<T>.Empty, CreateTensor(1)));
+            Assert.Throws<ArgumentException>(() => ProductOfDifferences(CreateTensor(1), ReadOnlySpan<T>.Empty));
+            Assert.Throws<ArgumentException>(() => ProductOfDifferences(CreateTensor(44), CreateTensor(43)));
+            Assert.Throws<ArgumentException>(() => ProductOfDifferences(CreateTensor(43), CreateTensor(44)));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void ProductOfDifferences(int tensorLength)
+        [Fact]
+        public void ProductOfDifferences_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-
-            float f = x[0] - y[0];
-            for (int i = 1; i < x.Length; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                f *= x[i] - y[i];
-            }
-            AssertEqualTolerance(f, TensorPrimitives.ProductOfDifferences(x, y));
-        }
-
-        [Theory]
-        [InlineData(0, new float[] {0 }, new float[] {0})]
-        [InlineData(0, new float[] {1 }, new float[] {1})]
-        [InlineData(1, new float[] {1 }, new float[] {0})]
-        [InlineData(-1, new float[] {0 }, new float[] {1})]
-        [InlineData(-1, new float[] {1, 2, 3, 4, 5 }, new float[] {2, 3, 4, 5, 6})]
-        [InlineData(120, new float[] {1, 2, 3, 4, 5 }, new float[] {0, 0, 0, 0, 0})]
-        [InlineData(-120, new float[] {0, 0, 0, 0, 0 }, new float[] {1, 2, 3, 4, 5})]
-        [InlineData(float.NaN, new float[] {1, 2, float.NaN, 4, 5 }, new float[] {0, 0, 0, 0, 0})]
-        public static void ProductOfDifferences_KnownValues(float expected, float[] x, float[] y)
-        {
-            Assert.Equal(expected, TensorPrimitives.ProductOfDifferences(x, y));
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
 
+                T f = Subtract(x[0], y[0]);
+                for (int i = 1; i < x.Length; i++)
+                {
+                    f = Multiply(f, Subtract(x[i], y[i]));
+                }
+                AssertEqualTolerance(f, ProductOfDifferences(x, y));
+            });
         }
         #endregion
 
         #region ProductOfSums
         [Fact]
-        public static void ProductOfSums_ThrowsForEmptyAndMismatchedLengths()
+        public void ProductOfSums_ThrowsForEmptyAndMismatchedLengths()
         {
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.ProductOfSums(ReadOnlySpan<float>.Empty, ReadOnlySpan<float>.Empty));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.ProductOfSums(ReadOnlySpan<float>.Empty, CreateTensor(1)));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.ProductOfSums(CreateTensor(1), ReadOnlySpan<float>.Empty));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.ProductOfSums(CreateTensor(44), CreateTensor(43)));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.ProductOfSums(CreateTensor(43), CreateTensor(44)));
+            Assert.Throws<ArgumentException>(() => ProductOfSums(ReadOnlySpan<T>.Empty, ReadOnlySpan<T>.Empty));
+            Assert.Throws<ArgumentException>(() => ProductOfSums(ReadOnlySpan<T>.Empty, CreateTensor(1)));
+            Assert.Throws<ArgumentException>(() => ProductOfSums(CreateTensor(1), ReadOnlySpan<T>.Empty));
+            Assert.Throws<ArgumentException>(() => ProductOfSums(CreateTensor(44), CreateTensor(43)));
+            Assert.Throws<ArgumentException>(() => ProductOfSums(CreateTensor(43), CreateTensor(44)));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void ProductOfSums(int tensorLength)
+        [Fact]
+        public void ProductOfSums_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-
-            float f = x[0] + y[0];
-            for (int i = 1; i < x.Length; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                f *= x[i] + y[i];
-            }
-            AssertEqualTolerance(f, TensorPrimitives.ProductOfSums(x, y));
-        }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
 
-        [Theory]
-        [InlineData(0, new float[] {0 }, new float[] { 0 })]
-        [InlineData(1, new float[] {0 }, new float[] { 1 })]
-        [InlineData(1, new float[] {1 }, new float[] { 0 })]
-        [InlineData(2, new float[] {1 }, new float[] { 1 })]
-        [InlineData(10395, new float[] {1, 2, 3, 4, 5 }, new float[] { 2, 3, 4, 5, 6 })]
-        [InlineData(120, new float[] {1, 2, 3, 4, 5 }, new float[] { 0, 0, 0, 0, 0 })]
-        [InlineData(120, new float[] {0, 0, 0, 0, 0 }, new float[] { 1, 2, 3, 4, 5 })]
-        [InlineData(float.NaN, new float[] {1, 2, float.NaN, 4, 5 }, new float[] { 0, 0, 0, 0, 0 })]
-        public static void ProductOfSums_KnownValues(float expected, float[] x, float[] y)
-        {
-            Assert.Equal(expected, TensorPrimitives.ProductOfSums(x, y));
+                T f = Add(x[0], y[0]);
+                for (int i = 1; i < x.Length; i++)
+                {
+                    f = Multiply(f, Add(x[i], y[i]));
+                }
+                AssertEqualTolerance(f, ProductOfSums(x, y));
+            });
         }
         #endregion
 
         #region Sigmoid
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Sigmoid(int tensorLength)
+        [Fact]
+        public void Sigmoid_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
-
-            TensorPrimitives.Sigmoid(x, destination);
+            if (!IsFloatingPoint) return;
 
-            for (int i = 0; i < tensorLength; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                AssertEqualTolerance(1f / (1f + MathF.Exp(-x[i])), destination[i]);
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Sigmoid_InPlace(int tensorLength)
-        {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Sigmoid(x, x);
+                Sigmoid(x, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(1f / (1f + MathF.Exp(-xOrig[i])), x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Divide(One, Add(One, Exp(Multiply(x[i], NegativeOne)))), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Sigmoid_SpecialValues(int tensorLength)
+        [Fact]
+        public void Sigmoid_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            RunForEachSpecialValue(() =>
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                TensorPrimitives.Sigmoid(x, destination);
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+
+                Sigmoid(x, x);
+
                 for (int i = 0; i < tensorLength; i++)
                 {
-                    AssertEqualTolerance(1f / (1f + MathF.Exp(-x[i])), destination[i]);
+                    AssertEqualTolerance(Divide(One, Add(One, Exp(Multiply(xOrig[i], NegativeOne)))), x[i]);
                 }
-            }, x);
+            });
         }
 
-        [Theory]
-        [InlineData(new float[] { -5, -4.5f, -4 }, new float[] { 0.0066f, 0.0109f, 0.0179f })]
-        [InlineData(new float[] { 4.5f, 5 }, new float[] { 0.9890f, 0.9933f })]
-        [InlineData(new float[] { 0, -3, 3, .5f }, new float[] { 0.5f, 0.0474f, 0.9525f, 0.6224f })]
-        public static void Sigmoid_KnownValues(float[] x, float[] expectedResult)
+        [Fact]
+        public void Sigmoid_SpecialValues()
         {
-            using BoundedMemory<float> dest = CreateTensor(x.Length);
-            TensorPrimitives.Sigmoid(x, dest);
+            if (!IsFloatingPoint) return;
 
-            for (int i = 0; i < x.Length; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                AssertEqualTolerance(expectedResult[i], dest[i], 0.0001f);
-            }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                RunForEachSpecialValue(() =>
+                {
+                    Sigmoid(x, destination);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(Divide(One, Add(One, Exp(Multiply(x[i], NegativeOne)))), destination[i]);
+                    }
+                }, x);
+            });
         }
 
-        [Theory]
-        [InlineData(new float[] { -5, -4.5f, -4 }, new float[] { 0.0066f, 0.0109f, 0.0179f })]
-        public static void Sigmoid_DestinationLongerThanSource(float[] x, float[] expectedResult)
+        [Fact]
+        public void Sigmoid_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> dest = CreateTensor(x.Length + 1);
-
-            TensorPrimitives.Sigmoid(x, dest);
+            if (!IsFloatingPoint) return;
 
-            float originalLast = dest[dest.Length - 1];
-            for (int i = 0; i < x.Length; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                AssertEqualTolerance(expectedResult[i], dest[i], 0.0001f);
-            }
-            Assert.Equal(originalLast, dest[dest.Length - 1]);
-        }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Sigmoid_ThrowsForTooShortDestination(int tensorLength)
-        {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
-
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Sigmoid(x, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Sigmoid(x, destination));
+            });
         }
 
         [Fact]
-        public static void Sigmoid_ThrowsForEmptyInput()
+        public void Sigmoid_ThrowsForEmptyInput()
         {
-            AssertExtensions.Throws<ArgumentException>(() => TensorPrimitives.Sigmoid(ReadOnlySpan<float>.Empty, CreateTensor(1)));
+            if (!IsFloatingPoint) return;
+
+            AssertExtensions.Throws<ArgumentException>(() => Sigmoid(ReadOnlySpan<T>.Empty, CreateTensor(1)));
         }
 
         [Fact]
-        public static void Sigmoid_ThrowsForOverlapppingInputsWithOutputs()
+        public void Sigmoid_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Sigmoid(array.AsSpan(1, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Sigmoid(array.AsSpan(1, 2), array.AsSpan(2, 2)));
+            if (!IsFloatingPoint) return;
+
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Sigmoid(array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Sigmoid(array.AsSpan(1, 2), array.AsSpan(2, 2)));
         }
         #endregion
 
         #region Sinh
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Sinh(int tensorLength)
+        [Fact]
+        public void Sinh_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
-
-            TensorPrimitives.Sinh(x, destination);
+            if (!IsFloatingPoint) return;
 
-            for (int i = 0; i < tensorLength; i++)
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                AssertEqualTolerance(MathF.Sinh(x[i]), destination[i]);
-            }
-        }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Sinh_InPlace(int tensorLength)
-        {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
-
-            TensorPrimitives.Sinh(x, x);
+                Sinh(x, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Sinh(xOrig[i]), x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Sinh(x[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Sinh_SpecialValues(int tensorLength)
+        [Fact]
+        public void Sinh_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            RunForEachSpecialValue(() =>
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                TensorPrimitives.Sinh(x, destination);
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+
+                Sinh(x, x);
+
                 for (int i = 0; i < tensorLength; i++)
                 {
-                    AssertEqualTolerance(MathF.Sinh(x[i]), destination[i]);
+                    AssertEqualTolerance(Sinh(xOrig[i]), x[i]);
                 }
-            }, x);
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(VectorLengthAndIteratedRange), new object[] { -100f, 100f, 3f })]
-        public static void Sinh_ValueRange(int vectorLengths, float element)
+        [Fact]
+        public void Sinh_SpecialValues()
         {
-            float[] x = new float[vectorLengths];
-            float[] dest = new float[vectorLengths];
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                RunForEachSpecialValue(() =>
+                {
+                    Sinh(x, destination);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(Sinh(x[i]), destination[i]);
+                    }
+                }, x);
+            });
+        }
 
-            x.AsSpan().Fill(element);
-            TensorPrimitives.Sinh(x, dest);
+        [Fact]
+        public void Sinh_ValueRange()
+        {
+            if (!IsFloatingPoint) return;
 
-            float expected = MathF.Sinh(element);
-            foreach (float actual in dest)
+            Assert.All(VectorLengthAndIteratedRange(ConvertFromSingle(-100f), ConvertFromSingle(100f), ConvertFromSingle(3f)), args =>
             {
-                AssertEqualTolerance(expected, actual);
-            }
+                T[] x = new T[args.Length];
+                T[] dest = new T[args.Length];
+
+                x.AsSpan().Fill(args.Element);
+                Sinh(x, dest);
+
+                T expected = Sinh(args.Element);
+                foreach (T actual in dest)
+                {
+                    AssertEqualTolerance(expected, actual);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Sinh_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Sinh_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            if (!IsFloatingPoint) return;
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Sinh(x, destination));
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
+
+                AssertExtensions.Throws<ArgumentException>("destination", () => Sinh(x, destination));
+            });
         }
 
         [Fact]
-        public static void Sinh_ThrowsForOverlapppingInputsWithOutputs()
+        public void Sinh_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Sinh(array.AsSpan(1, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Sinh(array.AsSpan(1, 2), array.AsSpan(2, 2)));
+            if (!IsFloatingPoint) return;
+
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Sinh(array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Sinh(array.AsSpan(1, 2), array.AsSpan(2, 2)));
         }
         #endregion
 
         #region SoftMax
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void SoftMax(int tensorLength)
+        [Fact]
+        public void SoftMax_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            TensorPrimitives.SoftMax(x, destination);
-
-            float expSum = MemoryMarshal.ToEnumerable<float>(x.Memory).Sum(MathF.Exp);
-            for (int i = 0; i < tensorLength; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                AssertEqualTolerance(MathF.Exp(x[i]) / expSum, destination[i]);
-            }
-        }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void SoftMax_InPlace(int tensorLength)
-        {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+                SoftMax(x, destination);
 
-            TensorPrimitives.SoftMax(x, x);
+                T expSum = Zero;
+                foreach (T value in x.Memory.Span)
+                {
+                    expSum = Add(expSum, Exp(value));
+                }
 
-            float expSum = xOrig.Sum(MathF.Exp);
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Exp(xOrig[i]) / expSum, x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Divide(Exp(x[i]), expSum), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [InlineData(new float[] { 3, 1, .2f }, new float[] { 0.8360188f, 0.11314284f, 0.05083836f })]
-        [InlineData(new float[] { 3, 4, 1 }, new float[] { 0.2594f, 0.705384f, 0.0351f })]
-        [InlineData(new float[] { 5, 3 }, new float[] { 0.8807f, 0.1192f })]
-        [InlineData(new float[] { 4, 2, 1, 9 }, new float[] { 0.0066f, 9.04658e-4f, 3.32805e-4f, 0.9920f })]
-        public static void SoftMax_KnownValues(float[] x, float[] expectedResult)
+        [Fact]
+        public void SoftMax_InPlace()
         {
-            using BoundedMemory<float> dest = CreateTensor(x.Length);
-            TensorPrimitives.SoftMax(x, dest);
+            if (!IsFloatingPoint) return;
 
-            for (int i = 0; i < x.Length; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                AssertEqualTolerance(expectedResult[i], dest[i], 0.0001f);
-            }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+
+                SoftMax(x, x);
+
+                T expSum = Zero;
+                foreach (T value in xOrig)
+                {
+                    expSum = Add(expSum, Exp(value));
+                }
+
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Divide(Exp(xOrig[i]), expSum), x[i]);
+                }
+            });
         }
 
         [Fact]
-        public static void SoftMax_DestinationLongerThanSource()
+        public void SoftMax_ThrowsForTooShortDestination()
         {
-            float[] x = [3, 1, .2f];
-            float[] expectedResult = [0.8360188f, 0.11314284f, 0.05083836f];
-            using BoundedMemory<float> dest = CreateTensor(x.Length + 1);
-            TensorPrimitives.SoftMax(x, dest);
+            if (!IsFloatingPoint) return;
 
-            for (int i = 0; i < x.Length; i++)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                AssertEqualTolerance(expectedResult[i], dest[i]);
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void SoftMax_ThrowsForTooShortDestination(int tensorLength)
-        {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.SoftMax(x, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => SoftMax(x, destination));
+            });
         }
 
         [Fact]
-        public static void SoftMax_ThrowsForEmptyInput()
+        public void SoftMax_ThrowsForEmptyInput()
         {
-            AssertExtensions.Throws<ArgumentException>(() => TensorPrimitives.SoftMax(ReadOnlySpan<float>.Empty, CreateTensor(1)));
+            if (!IsFloatingPoint) return;
+
+            AssertExtensions.Throws<ArgumentException>(() => SoftMax(ReadOnlySpan<T>.Empty, CreateTensor(1)));
         }
 
         [Fact]
-        public static void SoftMax_ThrowsForOverlapppingInputsWithOutputs()
+        public void SoftMax_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.SoftMax(array.AsSpan(1, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.SoftMax(array.AsSpan(1, 2), array.AsSpan(2, 2)));
+            if (!IsFloatingPoint) return;
+
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => SoftMax(array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => SoftMax(array.AsSpan(1, 2), array.AsSpan(2, 2)));
         }
         #endregion
 
         #region Subtract
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Subtract_TwoTensors(int tensorLength)
+        [Fact]
+        public void Subtract_TwoTensors()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Subtract(x, y, destination);
+                Subtract(x, y, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(x[i] - y[i], destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Subtract(x[i], y[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Subtract_TwoTensors_InPlace(int tensorLength)
+        [Fact]
+        public void Subtract_TwoTensors_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
 
-            TensorPrimitives.Subtract(x, x, x);
+                Subtract(x, x, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(xOrig[i] - xOrig[i], x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Zero, x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Subtract_TwoTensors_ThrowsForMismatchedLengths(int tensorLength)
+        [Fact]
+        public void Subtract_TwoTensors_ThrowsForMismatchedLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength - 1);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength - 1);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Subtract(x, y, destination));
-            Assert.Throws<ArgumentException>(() => TensorPrimitives.Subtract(y, x, destination));
+                Assert.Throws<ArgumentException>(() => Subtract(x, y, destination));
+                Assert.Throws<ArgumentException>(() => Subtract(y, x, destination));
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Subtract_TwoTensors_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Subtract_TwoTensors_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> y = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> y = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Subtract(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Subtract(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void Subtract_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
+        public void Subtract_TwoTensors_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Subtract(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Subtract(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Subtract(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Subtract(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Subtract(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Subtract(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(2, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Subtract(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(3, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Subtract(array.AsSpan(1, 2), array.AsSpan(4, 2), array.AsSpan(5, 2)));
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Subtract_TensorScalar(int tensorLength)
+        [Fact]
+        public void Subtract_TensorScalar()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Subtract(x, y, destination);
+                Subtract(x, y, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(x[i] - y, destination[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Subtract(x[i], y), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Subtract_TensorScalar_InPlace(int tensorLength)
+        [Fact]
+        public void Subtract_TensorScalar_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
-            float y = NextSingle();
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+                T y = NextRandom();
 
-            TensorPrimitives.Subtract(x, y, x);
+                Subtract(x, y, x);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(xOrig[i] - y, x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Subtract(xOrig[i], y), x[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Subtract_TensorScalar_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Subtract_TensorScalar_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float y = NextSingle();
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T y = NextRandom();
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Subtract(x, y, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Subtract(x, y, destination));
+            });
         }
 
         [Fact]
-        public static void Subtract_TensorScalar_ThrowsForOverlapppingInputsWithOutputs()
+        public void Subtract_TensorScalar_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Subtract(array.AsSpan(1, 2), 42, array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Subtract(array.AsSpan(1, 2), 42, array.AsSpan(2, 2)));
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Subtract(array.AsSpan(1, 2), default(T), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Subtract(array.AsSpan(1, 2), default(T), array.AsSpan(2, 2)));
         }
         #endregion
 
         #region Sum
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Sum(int tensorLength)
+        [Fact]
+        public void Sum_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-
-            AssertEqualTolerance(MemoryMarshal.ToEnumerable<float>(x.Memory).Sum(), TensorPrimitives.Sum(x));
-
-            float sum = 0;
-            foreach (float f in x.Span)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                sum += f;
-            }
-            AssertEqualTolerance(sum, TensorPrimitives.Sum(x));
-        }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
 
-        [Theory]
-        [InlineData(0, new float[] { 0 })]
-        [InlineData(1, new float[] { 0, 1 })]
-        [InlineData(6, new float[] { 1, 2, 3 })]
-        [InlineData(0, new float[] { -3, 0, 3 })]
-        [InlineData(float.NaN, new float[] { -3, float.NaN, 3 })]
-        public static void Sum_KnownValues(float expected, float[] x)
-        {
-            Assert.Equal(expected, TensorPrimitives.Sum(x));
+                T sum = Zero;
+                foreach (T value in x.Memory.Span)
+                {
+                    sum = Add(sum, value);
+                }
+                AssertEqualTolerance(sum, Sum(x));
+            });
         }
         #endregion
 
         #region SumOfMagnitudes
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void SumOfMagnitudes(int tensorLength)
+        [Fact]
+        public void SumOfMagnitudes_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-
-            AssertEqualTolerance(Enumerable.Sum(MemoryMarshal.ToEnumerable<float>(x.Memory), MathF.Abs), TensorPrimitives.SumOfMagnitudes(x));
-
-            float sum = 0;
-            foreach (float f in x.Span)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                sum += MathF.Abs(f);
-            }
-            AssertEqualTolerance(sum, TensorPrimitives.SumOfMagnitudes(x));
-        }
+                using BoundedMemory<T> x = CreateTensor(tensorLength);
+                FillTensor(x, MinValue);
 
-        [Theory]
-        [InlineData(0, new float[] { 0 })]
-        [InlineData(1, new float[] { 0, 1 })]
-        [InlineData(6, new float[] { 1, 2, 3 })]
-        [InlineData(6, new float[] { -3, 0, 3 })]
-        [InlineData(float.NaN, new float[] { -3, float.NaN, 3 })]
-        public static void SumOfMagnitudes_KnownValues(float expected, float[] x)
-        {
-            Assert.Equal(expected, TensorPrimitives.SumOfMagnitudes(x));
+                T sum = Zero;
+                foreach (T value in x.Memory.Span)
+                {
+                    sum = Add(sum, Abs(value));
+                }
+                AssertEqualTolerance(sum, SumOfMagnitudes(x));
+            });
         }
         #endregion
 
         #region SumOfSquares
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void SumOfSquares(int tensorLength)
+        [Fact]
+        public void SumOfSquares_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-
-            AssertEqualTolerance(Enumerable.Sum(MemoryMarshal.ToEnumerable<float>(x.Memory), v => v * v), TensorPrimitives.SumOfSquares(x));
-
-            float sum = 0;
-            foreach (float f in x.Span)
+            Assert.All(Helpers.TensorLengths, tensorLength =>
             {
-                sum += f * f;
-            }
-            AssertEqualTolerance(sum, TensorPrimitives.SumOfSquares(x));
-        }
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
 
-        [Theory]
-        [InlineData(0, new float[] { 0 })]
-        [InlineData(1, new float[] { 0, 1 })]
-        [InlineData(14, new float[] { 1, 2, 3 })]
-        [InlineData(18, new float[] { -3, 0, 3 })]
-        [InlineData(float.NaN, new float[] { -3, float.NaN, 3 })]
-        public static void SumOfSquares_KnownValues(float expected, float[] x)
-        {
-            Assert.Equal(expected, TensorPrimitives.SumOfSquares(x));
+                T sum = Zero;
+                foreach (T value in x.Memory.Span)
+                {
+                    sum = Add(sum, Multiply(value, value));
+                }
+                AssertEqualTolerance(sum, SumOfSquares(x));
+            });
         }
         #endregion
 
         #region Tanh
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Tanh(int tensorLength)
+        [Fact]
+        public void Tanh_AllLengths()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            TensorPrimitives.Tanh(x, destination);
-
-            for (int i = 0; i < tensorLength; i++)
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                AssertEqualTolerance(MathF.Tanh(x[i]), destination[i]);
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void Tanh_InPlace(int tensorLength)
-        {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            float[] xOrig = x.Span.ToArray();
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
 
-            TensorPrimitives.Tanh(x, x);
+                Tanh(x, destination);
 
-            for (int i = 0; i < tensorLength; i++)
-            {
-                AssertEqualTolerance(MathF.Tanh(xOrig[i]), x[i]);
-            }
+                for (int i = 0; i < tensorLength; i++)
+                {
+                    AssertEqualTolerance(Tanh(x[i]), destination[i]);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Tanh_SpecialValues(int tensorLength)
+        [Fact]
+        public void Tanh_InPlace()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
+            if (!IsFloatingPoint) return;
 
-            RunForEachSpecialValue(() =>
+            Assert.All(Helpers.TensorLengthsIncluding0, tensorLength =>
             {
-                TensorPrimitives.Tanh(x, destination);
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                T[] xOrig = x.Span.ToArray();
+
+                Tanh(x, x);
+
                 for (int i = 0; i < tensorLength; i++)
                 {
-                    AssertEqualTolerance(MathF.Tanh(x[i]), destination[i]);
+                    AssertEqualTolerance(Tanh(xOrig[i]), x[i]);
                 }
-            }, x);
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(VectorLengthAndIteratedRange), new object[] { -11f, 11f, 0.2f })]
-        public static void Tanh_ValueRange(int vectorLengths, float element)
+        [Fact]
+        public void Tanh_SpecialValues()
         {
-            float[] x = new float[vectorLengths];
-            float[] dest = new float[vectorLengths];
+            if (!IsFloatingPoint) return;
 
-            x.AsSpan().Fill(element);
-            TensorPrimitives.Tanh(x, dest);
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength);
+
+                RunForEachSpecialValue(() =>
+                {
+                    Tanh(x, destination);
+                    for (int i = 0; i < tensorLength; i++)
+                    {
+                        AssertEqualTolerance(Tanh(x[i]), destination[i]);
+                    }
+                }, x);
+            });
+        }
 
-            float expected = MathF.Tanh(element);
-            foreach (float actual in dest)
+        [Fact]
+        public void Tanh_ValueRange()
+        {
+            if (!IsFloatingPoint) return;
+
+            Assert.All(VectorLengthAndIteratedRange(ConvertFromSingle(-11f), ConvertFromSingle(11f), ConvertFromSingle(0.2f)), args =>
             {
-                AssertEqualTolerance(expected, actual);
-            }
+                T[] x = new T[args.Length];
+                T[] dest = new T[args.Length];
+
+                x.AsSpan().Fill(args.Element);
+                Tanh(x, dest);
+
+                T expected = Tanh(args.Element);
+                foreach (T actual in dest)
+                {
+                    AssertEqualTolerance(expected, actual);
+                }
+            });
         }
 
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void Tanh_ThrowsForTooShortDestination(int tensorLength)
+        [Fact]
+        public void Tanh_ThrowsForTooShortDestination()
         {
-            using BoundedMemory<float> x = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<float> destination = CreateTensor(tensorLength - 1);
+            if (!IsFloatingPoint) return;
+
+            Assert.All(Helpers.TensorLengths, tensorLength =>
+            {
+                using BoundedMemory<T> x = CreateAndFillTensor(tensorLength);
+                using BoundedMemory<T> destination = CreateTensor(tensorLength - 1);
 
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Tanh(x, destination));
+                AssertExtensions.Throws<ArgumentException>("destination", () => Tanh(x, destination));
+            });
         }
 
         [Fact]
-        public static void Tanh_ThrowsForOverlapppingInputsWithOutputs()
+        public void Tanh_ThrowsForOverlapppingInputsWithOutputs()
         {
-            float[] array = new float[10];
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Tanh(array.AsSpan(1, 2), array.AsSpan(0, 2)));
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.Tanh(array.AsSpan(1, 2), array.AsSpan(2, 2)));
+            if (!IsFloatingPoint) return;
+
+            T[] array = new T[10];
+            AssertExtensions.Throws<ArgumentException>("destination", () => Tanh(array.AsSpan(1, 2), array.AsSpan(0, 2)));
+            AssertExtensions.Throws<ArgumentException>("destination", () => Tanh(array.AsSpan(1, 2), array.AsSpan(2, 2)));
         }
         #endregion
     }
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.netcore.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.netcore.cs
deleted file mode 100644
index 06ab341db16242..00000000000000
--- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.netcore.cs
+++ /dev/null
@@ -1,142 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Buffers;
-using Xunit;
-
-namespace System.Numerics.Tensors.Tests
-{
-    public static partial class TensorPrimitivesTests
-    {
-        #region ConvertToHalf
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void ConvertToHalf(int tensorLength)
-        {
-            using BoundedMemory<float> source = CreateAndFillTensor(tensorLength);
-            foreach (int destLength in new[] { source.Length, source.Length + 1 })
-            {
-                using BoundedMemory<Half> destination = BoundedMemory.Allocate<Half>(destLength);
-                destination.Span.Fill(Half.Zero);
-
-                TensorPrimitives.ConvertToHalf(source, destination);
-
-                for (int i = 0; i < source.Length; i++)
-                {
-                    Assert.Equal((Half)source[i], destination[i]);
-                }
-
-                if (destination.Length > source.Length)
-                {
-                    for (int i = source.Length; i < destination.Length; i++)
-                    {
-                        Assert.Equal(Half.Zero, destination[i]);
-                    }
-                }
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void ConvertToHalf_SpecialValues(int tensorLength)
-        {
-            using BoundedMemory<float> source = CreateAndFillTensor(tensorLength);
-            using BoundedMemory<Half> destination = BoundedMemory.Allocate<Half>(tensorLength);
-
-            // NaN, infinities, and 0s
-            source[s_random.Next(source.Length)] = float.NaN;
-            source[s_random.Next(source.Length)] = float.PositiveInfinity;
-            source[s_random.Next(source.Length)] = float.NegativeInfinity;
-            source[s_random.Next(source.Length)] = 0;
-            source[s_random.Next(source.Length)] = float.NegativeZero;
-
-            TensorPrimitives.ConvertToHalf(source, destination);
-
-            for (int i = 0; i < source.Length; i++)
-            {
-                Assert.Equal((Half)source[i], destination[i]);
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void ConvertToHalf_ThrowsForTooShortDestination(int tensorLength)
-        {
-            using BoundedMemory<float> source = CreateAndFillTensor(tensorLength);
-            Half[] destination = new Half[source.Length - 1];
-
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.ConvertToHalf(source, destination));
-        }
-        #endregion
-
-        #region ConvertToSingle
-        [Theory]
-        [MemberData(nameof(TensorLengthsIncluding0))]
-        public static void ConvertToSingle(int tensorLength)
-        {
-            using BoundedMemory<Half> source = BoundedMemory.Allocate<Half>(tensorLength);
-            for (int i = 0; i < source.Length; i++)
-            {
-                source[i] = (Half)s_random.NextSingle();
-            }
-
-            foreach (int destLength in new[] { source.Length, source.Length + 1 })
-            {
-                using BoundedMemory<float> destination = CreateTensor(destLength);
-                destination.Span.Fill(0f);
-
-                TensorPrimitives.ConvertToSingle(source, destination);
-
-                for (int i = 0; i < source.Length; i++)
-                {
-                    Assert.Equal((float)source[i], destination[i]);
-                }
-
-                if (destination.Length > source.Length)
-                {
-                    for (int i = source.Length; i < destination.Length; i++)
-                    {
-                        Assert.Equal(0f, destination[i]);
-                    }
-                }
-            }
-        }
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void ConvertToSingle_SpecialValues(int tensorLength)
-        {
-            using BoundedMemory<Half> source = BoundedMemory.Allocate<Half>(tensorLength);
-            for (int i = 0; i < source.Length; i++)
-            {
-                source[i] = (Half)s_random.NextSingle();
-            }
-
-            using BoundedMemory<float> destination = CreateTensor(tensorLength);
-
-            // NaN, infinities, and 0s
-            source[s_random.Next(source.Length)] = Half.NaN;
-            source[s_random.Next(source.Length)] = Half.PositiveInfinity;
-            source[s_random.Next(source.Length)] = Half.NegativeInfinity;
-            source[s_random.Next(source.Length)] = Half.Zero;
-            source[s_random.Next(source.Length)] = Half.NegativeZero;
-
-            TensorPrimitives.ConvertToSingle(source, destination);
-
-            for (int i = 0; i < source.Length; i++)
-            {
-                Assert.Equal((float)source[i], destination[i]);
-            }
-        }
-
-        [Theory]
-        [MemberData(nameof(TensorLengths))]
-        public static void ConvertToSingle_ThrowsForTooShortDestination(int tensorLength)
-        {
-            Half[] source = new Half[tensorLength];
-            using BoundedMemory<float> destination = CreateTensor(source.Length - 1);
-
-            AssertExtensions.Throws<ArgumentException>("destination", () => TensorPrimitives.ConvertToSingle(source, destination));
-        }
-        #endregion
-    }
-}