diff --git a/src/libraries/System.Numerics.Tensors/Directory.Build.props b/src/libraries/System.Numerics.Tensors/Directory.Build.props
deleted file mode 100644
index 36078bccbf7aa8..00000000000000
--- a/src/libraries/System.Numerics.Tensors/Directory.Build.props
+++ /dev/null
@@ -1,8 +0,0 @@
-<Project>
-  <Import Project="..\Directory.Build.props" />
-  <PropertyGroup>
-    <!-- This is a preview package. Do not mark as stable. -->
-    <SuppressFinalPackageVersion>true</SuppressFinalPackageVersion>
-    <IsShippingAssembly>false</IsShippingAssembly>
-  </PropertyGroup>
-</Project>
\ No newline at end of file
diff --git a/src/libraries/System.Numerics.Tensors/README.md b/src/libraries/System.Numerics.Tensors/README.md
index 026563de81306d..6190da60e77c51 100644
--- a/src/libraries/System.Numerics.Tensors/README.md
+++ b/src/libraries/System.Numerics.Tensors/README.md
@@ -1,2 +1,3 @@
 # System.Numerics.Tensors
-This library has not been shipped publicly and is not accepting contributions at this time.
\ No newline at end of file
+
+Provides APIs for performing primitive operations over tensors represented by spans of memory.
diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.cs
index 3161a4c7e780ce..c657a43a054dd6 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.cs
@@ -6,151 +6,27 @@
 
 namespace System.Numerics.Tensors
 {
-    public static partial class ArrayTensorExtensions
+    public static class TensorPrimitives
     {
-        public static System.Numerics.Tensors.CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this System.Array array, bool reverseStride = false) { throw null; }
-        public static System.Numerics.Tensors.CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this T[,,] array, bool reverseStride = false) { throw null; }
-        public static System.Numerics.Tensors.CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this T[,] array, bool reverseStride = false) { throw null; }
-        public static System.Numerics.Tensors.CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this T[] array) { throw null; }
-        public static System.Numerics.Tensors.SparseTensor<T> ToSparseTensor<T>(this System.Array array, bool reverseStride = false) { throw null; }
-        public static System.Numerics.Tensors.SparseTensor<T> ToSparseTensor<T>(this T[,,] array, bool reverseStride = false) { throw null; }
-        public static System.Numerics.Tensors.SparseTensor<T> ToSparseTensor<T>(this T[,] array, bool reverseStride = false) { throw null; }
-        public static System.Numerics.Tensors.SparseTensor<T> ToSparseTensor<T>(this T[] array) { throw null; }
-        public static System.Numerics.Tensors.DenseTensor<T> ToTensor<T>(this System.Array array, bool reverseStride = false) { throw null; }
-        public static System.Numerics.Tensors.DenseTensor<T> ToTensor<T>(this T[,,] array, bool reverseStride = false) { throw null; }
-        public static System.Numerics.Tensors.DenseTensor<T> ToTensor<T>(this T[,] array, bool reverseStride = false) { throw null; }
-        public static System.Numerics.Tensors.DenseTensor<T> ToTensor<T>(this T[] array) { throw null; }
-    }
-    public partial class CompressedSparseTensor<T> : System.Numerics.Tensors.Tensor<T>
-    {
-        public CompressedSparseTensor(System.Memory<T> values, System.Memory<int> compressedCounts, System.Memory<int> indices, int nonZeroCount, System.ReadOnlySpan<int> dimensions, bool reverseStride = false) : base (default(System.Array), default(bool)) { }
-        public CompressedSparseTensor(System.ReadOnlySpan<int> dimensions, bool reverseStride = false) : base (default(System.Array), default(bool)) { }
-        public CompressedSparseTensor(System.ReadOnlySpan<int> dimensions, int capacity, bool reverseStride = false) : base (default(System.Array), default(bool)) { }
-        public int Capacity { get { throw null; } }
-        public System.Memory<int> CompressedCounts { get { throw null; } }
-        public System.Memory<int> Indices { get { throw null; } }
-        public override T this[System.ReadOnlySpan<int> indices] { get { throw null; } set { } }
-        public int NonZeroCount { get { throw null; } }
-        public System.Memory<T> Values { get { throw null; } }
-        public override System.Numerics.Tensors.Tensor<T> Clone() { throw null; }
-        public override System.Numerics.Tensors.Tensor<TResult> CloneEmpty<TResult>(System.ReadOnlySpan<int> dimensions) { throw null; }
-        public override T GetValue(int index) { throw null; }
-        public override System.Numerics.Tensors.Tensor<T> Reshape(System.ReadOnlySpan<int> dimensions) { throw null; }
-        public override void SetValue(int index, T value) { }
-        public override System.Numerics.Tensors.CompressedSparseTensor<T> ToCompressedSparseTensor() { throw null; }
-        public override System.Numerics.Tensors.DenseTensor<T> ToDenseTensor() { throw null; }
-        public override System.Numerics.Tensors.SparseTensor<T> ToSparseTensor() { throw null; }
-    }
-    public partial class DenseTensor<T> : System.Numerics.Tensors.Tensor<T>
-    {
-        public DenseTensor(int length) : base (default(System.Array), default(bool)) { }
-        public DenseTensor(System.Memory<T> memory, System.ReadOnlySpan<int> dimensions, bool reverseStride = false) : base (default(System.Array), default(bool)) { }
-        public DenseTensor(System.ReadOnlySpan<int> dimensions, bool reverseStride = false) : base (default(System.Array), default(bool)) { }
-        public System.Memory<T> Buffer { get { throw null; } }
-        public override System.Numerics.Tensors.Tensor<T> Clone() { throw null; }
-        public override System.Numerics.Tensors.Tensor<TResult> CloneEmpty<TResult>(System.ReadOnlySpan<int> dimensions) { throw null; }
-        protected override void CopyTo(T[] array, int arrayIndex) { }
-        public override T GetValue(int index) { throw null; }
-        protected override int IndexOf(T item) { throw null; }
-        public override System.Numerics.Tensors.Tensor<T> Reshape(System.ReadOnlySpan<int> dimensions) { throw null; }
-        public override void SetValue(int index, T value) { }
-    }
-    public partial class SparseTensor<T> : System.Numerics.Tensors.Tensor<T>
-    {
-        public SparseTensor(System.ReadOnlySpan<int> dimensions, bool reverseStride = false, int capacity = 0) : base (default(System.Array), default(bool)) { }
-        public int NonZeroCount { get { throw null; } }
-        public override System.Numerics.Tensors.Tensor<T> Clone() { throw null; }
-        public override System.Numerics.Tensors.Tensor<TResult> CloneEmpty<TResult>(System.ReadOnlySpan<int> dimensions) { throw null; }
-        public override T GetValue(int index) { throw null; }
-        public override System.Numerics.Tensors.Tensor<T> Reshape(System.ReadOnlySpan<int> dimensions) { throw null; }
-        public override void SetValue(int index, T value) { }
-        public override System.Numerics.Tensors.CompressedSparseTensor<T> ToCompressedSparseTensor() { throw null; }
-        public override System.Numerics.Tensors.DenseTensor<T> ToDenseTensor() { throw null; }
-        public override System.Numerics.Tensors.SparseTensor<T> ToSparseTensor() { throw null; }
-    }
-    public static partial class Tensor
-    {
-        public static System.Numerics.Tensors.Tensor<T> CreateFromDiagonal<T>(System.Numerics.Tensors.Tensor<T> diagonal) { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateFromDiagonal<T>(System.Numerics.Tensors.Tensor<T> diagonal, int offset) { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateIdentity<T>(int size) { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateIdentity<T>(int size, bool columMajor) { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateIdentity<T>(int size, bool columMajor, T oneValue) { throw null; }
-    }
-    public abstract partial class Tensor<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
-    {
-        protected Tensor(System.Array fromArray, bool reverseStride) { }
-        protected Tensor(int length) { }
-        protected Tensor(System.ReadOnlySpan<int> dimensions, bool reverseStride) { }
-        public System.ReadOnlySpan<int> Dimensions { get { throw null; } }
-        public bool IsFixedSize { get { throw null; } }
-        public bool IsReadOnly { get { throw null; } }
-        public bool IsReversedStride { get { throw null; } }
-        public virtual T this[params int[] indices] { get { throw null; } set { } }
-        public virtual T this[System.ReadOnlySpan<int> indices] { get { throw null; } set { } }
-        public long Length { get { throw null; } }
-        public int Rank { get { throw null; } }
-        public System.ReadOnlySpan<int> Strides { get { throw null; } }
-        int System.Collections.Generic.ICollection<T>.Count { get { throw null; } }
-        T System.Collections.Generic.IList<T>.this[int index] { get { throw null; } set { } }
-        int System.Collections.Generic.IReadOnlyCollection<T>.Count { get { throw null; } }
-        T System.Collections.Generic.IReadOnlyList<T>.this[int index] { get { throw null; } }
-        int System.Collections.ICollection.Count { get { throw null; } }
-        bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
-        object System.Collections.ICollection.SyncRoot { get { throw null; } }
-        object? System.Collections.IList.this[int index] { get { throw null; } set { } }
-        public abstract System.Numerics.Tensors.Tensor<T> Clone();
-        public virtual System.Numerics.Tensors.Tensor<T> CloneEmpty() { throw null; }
-        public virtual System.Numerics.Tensors.Tensor<T> CloneEmpty(System.ReadOnlySpan<int> dimensions) { throw null; }
-        public virtual System.Numerics.Tensors.Tensor<TResult> CloneEmpty<TResult>() { throw null; }
-        public abstract System.Numerics.Tensors.Tensor<TResult> CloneEmpty<TResult>(System.ReadOnlySpan<int> dimensions);
-        public static int Compare(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) { throw null; }
-        protected virtual bool Contains(T item) { throw null; }
-        protected virtual void CopyTo(T[] array, int arrayIndex) { }
-        public static bool Equals(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) { throw null; }
-        public virtual void Fill(T value) { }
-        public string GetArrayString(bool includeWhitespace = true) { throw null; }
-        public System.Numerics.Tensors.Tensor<T> GetDiagonal() { throw null; }
-        public System.Numerics.Tensors.Tensor<T> GetDiagonal(int offset) { throw null; }
-        public System.Numerics.Tensors.Tensor<T> GetTriangle() { throw null; }
-        public System.Numerics.Tensors.Tensor<T> GetTriangle(int offset) { throw null; }
-        public System.Numerics.Tensors.Tensor<T> GetUpperTriangle() { throw null; }
-        public System.Numerics.Tensors.Tensor<T> GetUpperTriangle(int offset) { throw null; }
-        public abstract T GetValue(int index);
-        protected virtual int IndexOf(T item) { throw null; }
-        public abstract System.Numerics.Tensors.Tensor<T> Reshape(System.ReadOnlySpan<int> dimensions);
-        public abstract void SetValue(int index, T value);
-        public struct Enumerator : System.Collections.Generic.IEnumerator<T>
-        {
-            public T Current { get; private set; }
-            object? System.Collections.IEnumerator.Current => throw null;
-            public bool MoveNext() => throw null;
-            public void Reset() { }
-            public void Dispose() { }
-        }
-        public Enumerator GetEnumerator() => throw null;
-        void System.Collections.Generic.ICollection<T>.Add(T item) { }
-        void System.Collections.Generic.ICollection<T>.Clear() { }
-        bool System.Collections.Generic.ICollection<T>.Contains(T item) { throw null; }
-        void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex) { }
-        bool System.Collections.Generic.ICollection<T>.Remove(T item) { throw null; }
-        System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
-        int System.Collections.Generic.IList<T>.IndexOf(T item) { throw null; }
-        void System.Collections.Generic.IList<T>.Insert(int index, T item) { }
-        void System.Collections.Generic.IList<T>.RemoveAt(int index) { }
-        void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
-        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
-        int System.Collections.IList.Add(object? value) { throw null; }
-        void System.Collections.IList.Clear() { }
-        bool System.Collections.IList.Contains(object? value) { throw null; }
-        int System.Collections.IList.IndexOf(object? value) { throw null; }
-        void System.Collections.IList.Insert(int index, object? value) { }
-        void System.Collections.IList.Remove(object? value) { }
-        void System.Collections.IList.RemoveAt(int index) { }
-        int System.Collections.IStructuralComparable.CompareTo(object? other, System.Collections.IComparer comparer) { throw null; }
-        bool System.Collections.IStructuralEquatable.Equals(object? other, System.Collections.IEqualityComparer comparer) { throw null; }
-        int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; }
-        public virtual System.Numerics.Tensors.CompressedSparseTensor<T> ToCompressedSparseTensor() { throw null; }
-        public virtual System.Numerics.Tensors.DenseTensor<T> ToDenseTensor() { throw null; }
-        public virtual System.Numerics.Tensors.SparseTensor<T> ToSparseTensor() { throw null; }
+        public static void Add(System.ReadOnlySpan<float> x, float y, System.Span<float> destination) { throw null; }
+        public static void Add(System.ReadOnlySpan<float> x, System.ReadOnlySpan<float> y, System.Span<float> destination) { throw null; }
+        public static void AddMultiply(System.ReadOnlySpan<float> x, float y, System.ReadOnlySpan<float> multiplier, System.Span<float> destination) { throw null; }
+        public static void AddMultiply(System.ReadOnlySpan<float> x, System.ReadOnlySpan<float> y, float multiplier, System.Span<float> destination) { throw null; }
+        public static void AddMultiply(System.ReadOnlySpan<float> x, System.ReadOnlySpan<float> y, System.ReadOnlySpan<float> multiplier, System.Span<float> destination) { throw null; }
+        public static void Cosh(System.ReadOnlySpan<float> x, System.Span<float> destination) { throw null; }
+        public static void Divide(System.ReadOnlySpan<float> x, float y, System.Span<float> destination) { throw null; }
+        public static void Divide(System.ReadOnlySpan<float> x, System.ReadOnlySpan<float> y, System.Span<float> destination) { throw null; }
+        public static void Exp(System.ReadOnlySpan<float> x, System.Span<float> destination) { throw null; }
+        public static void Log(System.ReadOnlySpan<float> x, System.Span<float> destination) { throw null; }
+        public static void Multiply(System.ReadOnlySpan<float> x, float y, System.Span<float> destination) { throw null; }
+        public static void Multiply(System.ReadOnlySpan<float> x, System.ReadOnlySpan<float> y, System.Span<float> destination) { throw null; }
+        public static void MultiplyAdd(System.ReadOnlySpan<float> x, float y, System.ReadOnlySpan<float> addend, System.Span<float> destination) { throw null; }
+        public static void MultiplyAdd(System.ReadOnlySpan<float> x, System.ReadOnlySpan<float> y, float addend, System.Span<float> destination) { throw null; }
+        public static void MultiplyAdd(System.ReadOnlySpan<float> x, System.ReadOnlySpan<float> y, System.ReadOnlySpan<float> addend, System.Span<float> destination) { throw null; }
+        public static void Negate(System.ReadOnlySpan<float> x, System.Span<float> destination) { throw null; }
+        public static void Subtract(System.ReadOnlySpan<float> x, float y, System.Span<float> destination) { throw null; }
+        public static void Subtract(System.ReadOnlySpan<float> x, System.ReadOnlySpan<float> y, System.Span<float> destination) { throw null; }
+        public static void Sinh(System.ReadOnlySpan<float> x, System.Span<float> destination) { throw null; }
+        public static void Tanh(System.ReadOnlySpan<float> x, System.Span<float> destination) { throw null; }
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.csproj
index cabfe50e267cfb..8d1d484b33ecd4 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.csproj
@@ -1,4 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
+
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppPrevious);$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
   </PropertyGroup>
@@ -10,4 +11,5 @@
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
   </ItemGroup>
+
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Numerics.Tensors/src/Properties/InternalsVisibleTo.cs b/src/libraries/System.Numerics.Tensors/src/Properties/InternalsVisibleTo.cs
deleted file mode 100644
index 2b044e474d570a..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/Properties/InternalsVisibleTo.cs
+++ /dev/null
@@ -1,6 +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.Runtime.CompilerServices;
-
-[assembly: InternalsVisibleTo("System.Numerics.Tensors.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
diff --git a/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx b/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
index 57f792dde51dc2..f9f7f45078a046 100644
--- a/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
+++ b/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
@@ -117,52 +117,10 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="ArrayMustContainElements" xml:space="preserve">
-    <value>Array must contain elements.</value>
+  <data name="Argument_DestinationTooShort" xml:space="preserve">
+    <value>Destination is too short.</value>
   </data>
-  <data name="CannotCompare" xml:space="preserve">
-    <value>Cannot compare {0} to {1}.</value>
-  </data>
-  <data name="CannotCompareToWithDifferentDimension" xml:space="preserve">
-    <value>Cannot compare {0} to {1} with different dimension {2}, {3} != {4}.</value>
-  </data>
-  <data name="CannotCompareWithDifferentDimension" xml:space="preserve">
-    <value>Cannot compare {0} with different dimension {1}, {2} != {3}.</value>
-  </data>
-  <data name="CannotCompareWithRank" xml:space="preserve">
-    <value>Cannot compare {0} with Rank {1} to {2} with Rank {3}.</value>
-  </data>
-  <data name="CannotComputeDiagonal" xml:space="preserve">
-    <value>Cannot compute diagonal of {0} with Rank less than 2.</value>
-  </data>
-  <data name="CannotComputeDiagonalWithOffset" xml:space="preserve">
-    <value>Cannot compute diagonal with offset {0}.</value>
-  </data>
-  <data name="MustHaveAtLeastOneDimension" xml:space="preserve">
-    <value>Tensor {0} must have at least one dimension.</value>
-  </data>
-  <data name="CannotComputeTriangle" xml:space="preserve">
-    <value>Cannot compute triangle of {0} with Rank less than 2.</value>
-  </data>
-  <data name="CannotReshapeArrayDueToMismatchInLengths" xml:space="preserve">
-    <value>Cannot reshape array due to mismatch in lengths, currently {0} would become {1}.</value>
-  </data>
-  <data name="DimensionsMustBePositiveAndNonZero" xml:space="preserve">
-    <value>Dimensions must be positive and non-zero.</value>
-  </data>
-  <data name="DimensionsMustContainElements" xml:space="preserve">
-    <value>Dimensions must contain elements.</value>
-  </data>
-  <data name="LengthMustMatch" xml:space="preserve">
-    <value>Length of {0} ({1}) must match product of {2} ({3}).</value>
-  </data>
-  <data name="NumberGreaterThenAvailableSpace" xml:space="preserve">
-    <value>The number of elements in the Tensor is greater than the available space from index to the end of the destination array.</value>
-  </data>
-  <data name="OnlySingleDimensionalArraysSupported" xml:space="preserve">
-    <value>Only single dimensional arrays are supported for the requested action.</value>
-  </data>
-  <data name="ValueIsNotOfType" xml:space="preserve">
-    <value>The value "{0}" is not of type "{1}" and cannot be used in this generic collection.</value>
+  <data name="Argument_SpansMustHaveSameLength" xml:space="preserve">
+    <value>Length of '{0}' must be same as length of '{1}'.</value>
   </data>
 </root>
\ No newline at end of file
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 521f8055a4fa61..5c188c2e0b841d 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -1,30 +1,28 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppPrevious);$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <!-- Public API not fully documented. -->
-    <NoWarn>$(NoWarn);1591</NoWarn>
     <IsPackable>true</IsPackable>
-    <PackageDescription>Tensor class which represents and extends multi-dimensional arrays.
-
-Commonly Used Types:
-System.Numerics.Tensors.Tensor&lt;T&gt;
-System.Numerics.Tensors.CompressedSparseTensor&lt;T&gt;
-System.Numerics.Tensors.DenseTensor&lt;T&gt;
-System.Numerics.Tensors.SparseTensor&lt;T&gt;</PackageDescription>
+    <PackageDescription>Provides support for operating over tensors.</PackageDescription>
+    <!-- Disabling baseline validation since this is a brand new package.
+         Once this package has shipped a stable version, the following line
+         should be removed in order to re-enable validation. -->
+    <DisablePackageBaselineValidation>true</DisablePackageBaselineValidation>
   </PropertyGroup>
 
   <ItemGroup>
-    <Compile Include="Properties\InternalsVisibleTo.cs" />
-    <Compile Include="System\Numerics\Tensors\ArrayTensorExtensions.cs" />
-    <Compile Include="System\Numerics\Tensors\ArrayUtilities.cs" />
-    <Compile Include="System\Numerics\Tensors\CompressedSparseTensor.cs" />
-    <Compile Include="System\Numerics\Tensors\DenseTensor.cs" />
-    <Compile Include="System\Numerics\Tensors\SparseTensor.cs" />
-    <Compile Include="System\Numerics\Tensors\Tensor.cs" />
+    <Compile Include="System\Numerics\Tensors\TensorPrimitives.cs" />
+    <Compile Include="System\ThrowHelper.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="System.Numerics.Tensors.Tests" Key="00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
+    <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Bcl.Numerics\src\Microsoft.Bcl.Numerics.csproj" />
   </ItemGroup>
+
 </Project>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/ArrayTensorExtensions.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/ArrayTensorExtensions.cs
deleted file mode 100644
index 05e12a62c990e4..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/ArrayTensorExtensions.cs
+++ /dev/null
@@ -1,149 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Numerics.Tensors
-{
-    public static class ArrayTensorExtensions
-    {
-        /// <summary>
-        /// Creates a copy of this single-dimensional array as a DenseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the DenseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a DenseTensor&lt;T&gt; from.</param>
-        /// <returns>A 1-dimensional DenseTensor&lt;T&gt; with the same length and content as <paramref name="array"/>.</returns>
-        public static DenseTensor<T> ToTensor<T>(this T[] array)
-        {
-            return new DenseTensor<T>(array);
-        }
-
-        /// <summary>
-        /// Creates a copy of this two-dimensional array as a DenseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the DenseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a DenseTensor&lt;T&gt; from.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): row-major.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): column-major.</param>
-        /// <returns>A 2-dimensional DenseTensor&lt;T&gt; with the same dimensions and content as <paramref name="array"/>.</returns>
-        public static DenseTensor<T> ToTensor<T>(this T[,] array, bool reverseStride = false)
-        {
-            return new DenseTensor<T>(array, reverseStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this three-dimensional array as a DenseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the DenseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a DenseTensor&lt;T&gt; from.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        /// <returns>A 3-dimensional DenseTensor&lt;T&gt; with the same dimensions and content as <paramref name="array"/>.</returns>
-        public static DenseTensor<T> ToTensor<T>(this T[,,] array, bool reverseStride = false)
-        {
-            return new DenseTensor<T>(array, reverseStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this n-dimensional array as a DenseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the DenseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a DenseTensor&lt;T&gt; from.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        /// <returns>A n-dimensional DenseTensor&lt;T&gt; with the same dimensions and content as <paramref name="array"/>.</returns>
-        public static DenseTensor<T> ToTensor<T>(this Array array, bool reverseStride = false)
-        {
-            return new DenseTensor<T>(array, reverseStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this single-dimensional array as a SparseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the SparseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a SparseTensor&lt;T&gt; from.</param>
-        /// <returns>A 1-dimensional SparseTensor&lt;T&gt; with the same length and content as <paramref name="array"/>.</returns>
-        public static SparseTensor<T> ToSparseTensor<T>(this T[] array)
-        {
-            return new SparseTensor<T>(array);
-        }
-
-        /// <summary>
-        /// Creates a copy of this two-dimensional array as a SparseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the SparseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a SparseTensor&lt;T&gt; from.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): row-major.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): column-major.</param>
-        /// <returns>A 2-dimensional SparseTensor&lt;T&gt; with the same dimensions and content as <paramref name="array"/>.</returns>
-        public static SparseTensor<T> ToSparseTensor<T>(this T[,] array, bool reverseStride = false)
-        {
-            return new SparseTensor<T>(array, reverseStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this three-dimensional array as a SparseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the SparseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a SparseTensor&lt;T&gt; from.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        /// <returns>A 3-dimensional SparseTensor&lt;T&gt; with the same dimensions and content as <paramref name="array"/>.</returns>
-        public static SparseTensor<T> ToSparseTensor<T>(this T[,,] array, bool reverseStride = false)
-        {
-            return new SparseTensor<T>(array, reverseStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this n-dimensional array as a SparseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the SparseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a SparseTensor&lt;T&gt; from.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        /// <returns>A n-dimensional SparseTensor&lt;T&gt; with the same dimensions and content as <paramref name="array"/>.</returns>
-        public static SparseTensor<T> ToSparseTensor<T>(this Array array, bool reverseStride = false)
-        {
-            return new SparseTensor<T>(array, reverseStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this single-dimensional array as a CompressedSparseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the CompressedSparseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a CompressedSparseTensor&lt;T&gt; from.</param>
-        /// <returns>A 1-dimensional CompressedSparseTensor&lt;T&gt; with the same length and content as <paramref name="array"/>.</returns>
-        public static CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this T[] array)
-        {
-            return new CompressedSparseTensor<T>(array);
-        }
-
-        /// <summary>
-        /// Creates a copy of this two-dimensional array as a CompressedSparseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the CompressedSparseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a CompressedSparseTensor&lt;T&gt; from.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): row-major.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): column-major.</param>
-        /// <returns>A 2-dimensional CompressedSparseTensor&lt;T&gt; with the same dimensions and content as <paramref name="array"/>.</returns>
-        public static CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this T[,] array, bool reverseStride = false)
-        {
-            return new CompressedSparseTensor<T>(array, reverseStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this three-dimensional array as a CompressedSparseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the CompressedSparseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a CompressedSparseTensor&lt;T&gt; from.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        /// <returns>A 3-dimensional CompressedSparseTensor&lt;T&gt; with the same dimensions and content as <paramref name="array"/>.</returns>
-        public static CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this T[,,] array, bool reverseStride = false)
-        {
-            return new CompressedSparseTensor<T>(array, reverseStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this n-dimensional array as a CompressedSparseTensor&lt;T&gt;
-        /// </summary>
-        /// <typeparam name="T">Type contained in the array to copy to the CompressedSparseTensor&lt;T&gt;.</typeparam>
-        /// <param name="array">The array to create a CompressedSparseTensor&lt;T&gt; from.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        /// <returns>A n-dimensional CompressedSparseTensor&lt;T&gt; with the same dimensions and content as <paramref name="array"/>.</returns>
-        public static CompressedSparseTensor<T> ToCompressedSparseTensor<T>(this Array array, bool reverseStride = false)
-        {
-            return new CompressedSparseTensor<T>(array, reverseStride);
-        }
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/ArrayUtilities.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/ArrayUtilities.cs
deleted file mode 100644
index 97152090dfea06..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/ArrayUtilities.cs
+++ /dev/null
@@ -1,216 +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.Diagnostics;
-
-namespace System.Numerics.Tensors
-{
-    internal static class ArrayUtilities
-    {
-        public const int StackallocMax = 16;
-
-        public static long GetProduct(ReadOnlySpan<int> dimensions, int startIndex = 0)
-        {
-            if (dimensions.Length == 0)
-            {
-                return 0;
-            }
-
-            long product = 1;
-            for (int i = startIndex; i < dimensions.Length; i++)
-            {
-                if (dimensions[i] < 0)
-                {
-                    throw new ArgumentOutOfRangeException($"{nameof(dimensions)}[{i}]");
-                }
-
-                // we use a long which should be much larger than is ever used here,
-                // but still force checked
-                checked
-                {
-                    product *= dimensions[i];
-                }
-            }
-
-            return product;
-        }
-
-        public static bool IsAscending(ReadOnlySpan<int> values)
-        {
-            for (int i = 1; i < values.Length; i++)
-            {
-                if (values[i] < values[i - 1])
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        public static bool IsDescending(ReadOnlySpan<int> values)
-        {
-            for (int i = 1; i < values.Length; i++)
-            {
-                if (values[i] > values[i - 1])
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Gets the set of strides that can be used to calculate the offset of n-dimensions in a 1-dimensional layout
-        /// </summary>
-        /// <param name="dimensions"></param>
-        /// <param name="reverseStride"></param>
-        /// <returns></returns>
-        public static int[] GetStrides(ReadOnlySpan<int> dimensions, bool reverseStride = false)
-        {
-            int[] strides = new int[dimensions.Length];
-
-            int stride = 1;
-            if (reverseStride)
-            {
-                for (int i = 0; i < strides.Length; i++)
-                {
-                    strides[i] = stride;
-                    stride *= dimensions[i];
-                }
-            }
-            else
-            {
-                for (int i = strides.Length - 1; i >= 0; i--)
-                {
-                    strides[i] = stride;
-                    stride *= dimensions[i];
-                }
-            }
-
-            return strides;
-        }
-
-        public static void SplitStrides(int[] strides, int[] splitAxes, int[] newStrides, int stridesOffset, int[] splitStrides, int splitStridesOffset)
-        {
-            int newStrideIndex = 0;
-            for (int i = 0; i < strides.Length; i++)
-            {
-                int stride = strides[i];
-                bool isSplit = false;
-                for (int j = 0; j < splitAxes.Length; j++)
-                {
-                    if (splitAxes[j] == i)
-                    {
-                        splitStrides[splitStridesOffset + j] = stride;
-                        isSplit = true;
-                        break;
-                    }
-                }
-
-                if (!isSplit)
-                {
-                    newStrides[stridesOffset + newStrideIndex++] = stride;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Calculates the 1-d index for n-d indices in layout specified by strides.
-        /// </summary>
-        /// <param name="strides"></param>
-        /// <param name="indices"></param>
-        /// <param name="startFromDimension"></param>
-        /// <returns></returns>
-        public static int GetIndex(int[] strides, ReadOnlySpan<int> indices, int startFromDimension = 0)
-        {
-            Debug.Assert(strides.Length == indices.Length);
-
-            int index = 0;
-            for (int i = startFromDimension; i < indices.Length; i++)
-            {
-                index += strides[i] * indices[i];
-            }
-
-            return index;
-        }
-
-        /// <summary>
-        /// Calculates the n-d indices from the 1-d index in a layout specified by strides
-        /// </summary>
-        /// <param name="strides"></param>
-        /// <param name="reverseStride"></param>
-        /// <param name="index"></param>
-        /// <param name="indices"></param>
-        /// <param name="startFromDimension"></param>
-        public static void GetIndices(ReadOnlySpan<int> strides, bool reverseStride, int index, int[] indices, int startFromDimension = 0)
-        {
-            Debug.Assert(reverseStride ? IsAscending(strides) : IsDescending(strides), "Index decomposition requires ordered strides");
-            Debug.Assert(strides.Length == indices.Length);
-
-            int remainder = index;
-            for (int i = startFromDimension; i < strides.Length; i++)
-            {
-                // reverse the index for reverseStride so that we divide by largest stride first
-                var nIndex = reverseStride ? strides.Length - 1 - i : i;
-
-                var stride = strides[nIndex];
-                indices[nIndex] = remainder / stride;
-                remainder %= stride;
-            }
-        }
-
-        /// <summary>
-        /// Calculates the n-d indices from the 1-d index in a layout specified by strides
-        /// </summary>
-        /// <param name="strides"></param>
-        /// <param name="reverseStride"></param>
-        /// <param name="index"></param>
-        /// <param name="indices"></param>
-        /// <param name="startFromDimension"></param>
-        public static void GetIndices(ReadOnlySpan<int> strides, bool reverseStride, int index, Span<int> indices, int startFromDimension = 0)
-        {
-            Debug.Assert(reverseStride ? IsAscending(strides) : IsDescending(strides), "Index decomposition requires ordered strides");
-            Debug.Assert(strides.Length == indices.Length);
-
-            int remainder = index;
-            for (int i = startFromDimension; i < strides.Length; i++)
-            {
-                // reverse the index for reverseStride so that we divide by largest stride first
-                var nIndex = reverseStride ? strides.Length - 1 - i : i;
-
-                var stride = strides[nIndex];
-                indices[nIndex] = remainder / stride;
-                remainder %= stride;
-            }
-        }
-
-        /// <summary>
-        /// Takes an 1-d index over n-d sourceStrides and recalculates it assuming same n-d coordinates over a different n-d strides
-        /// </summary>
-        public static int TransformIndexByStrides(int index, int[] sourceStrides, bool sourceReverseStride, int[] transformStrides)
-        {
-            Debug.Assert(index >= 0);
-            Debug.Assert(sourceReverseStride ? IsAscending(sourceStrides) : IsDescending(sourceStrides), "Index decomposition requires ordered strides");
-            Debug.Assert(sourceStrides.Length == transformStrides.Length);
-
-            int transformIndex = 0;
-            int remainder = index;
-
-            for (int i = 0; i < sourceStrides.Length; i++)
-            {
-                // reverse the index for reverseStride so that we divide by largest stride first
-                var nIndex = sourceReverseStride ? sourceStrides.Length - 1 - i : i;
-
-                var sourceStride = sourceStrides[nIndex];
-                var transformStride = transformStrides[nIndex];
-
-                transformIndex += transformStride * (remainder / sourceStride);
-                remainder %= sourceStride;
-            }
-
-            return transformIndex;
-        }
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/CompressedSparseTensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/CompressedSparseTensor.cs
deleted file mode 100644
index b41915acddd5ab..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/CompressedSparseTensor.cs
+++ /dev/null
@@ -1,517 +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.Diagnostics;
-using System.Linq;
-
-namespace System.Numerics.Tensors
-{
-    /// <summary>
-    /// Represents a tensor using compressed sparse format
-    /// For a two dimensional tensor this is referred to as compressed sparse row (CSR, CRS, Yale), compressed sparse column (CSC, CCS)
-    ///
-    /// In this format, data that is in the same value for the compressed dimension has locality
-    ///
-    /// In standard layout of a dense tensor, data with the same value for first dimensions has locality.
-    /// As such we'll use reverseStride = false (default) to mean that the first dimension is compressed (CSR)
-    /// and reverseStride = true to mean that the last dimension is compressed (CSC)
-    ///
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    public class CompressedSparseTensor<T> : Tensor<T>
-    {
-        private Memory<T> values;
-        private readonly Memory<int> compressedCounts;
-        private Memory<int> indices;
-
-        private int nonZeroCount;
-
-        private readonly int[] nonCompressedStrides;
-        private readonly int compressedDimension;
-
-        private const int defaultCapacity = 64;
-
-        /// <summary>
-        /// Constructs a new CompressedSparseTensor of the specified dimensions and stride ordering.
-        /// </summary>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the CompressedSparseTensor to create.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        public CompressedSparseTensor(ReadOnlySpan<int> dimensions, bool reverseStride = false) : this(dimensions, defaultCapacity, reverseStride)
-        { }
-
-        /// <summary>
-        /// Constructs a new CompressedSparseTensor of the specified dimensions, initial capacity, and stride ordering.
-        /// </summary>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the CompressedSparseTensor to create.</param>
-        /// <param name="capacity">The number of non-zero values this tensor can store without resizing.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        public CompressedSparseTensor(ReadOnlySpan<int> dimensions, int capacity, bool reverseStride = false) : base(dimensions, reverseStride)
-        {
-            nonZeroCount = 0;
-            compressedDimension = reverseStride ? Rank - 1 : 0;
-            nonCompressedStrides = (int[])strides.Clone();
-            nonCompressedStrides[compressedDimension] = 0;
-            var compressedDimensionLength = dimensions[compressedDimension];
-            compressedCounts = new int[compressedDimensionLength + 1];
-            values = new T[capacity];
-            indices = new int[capacity];
-        }
-
-        /// <summary>
-        /// Constructs a new CompressedSparseTensor of the specified dimensions, wrapping existing backing memory for the contents.
-        /// Growing this CompressedSparseTensor will re-allocate the backing memory.
-        /// </summary>
-        /// <param name="values">Memory storing non-zero values to construct this tensor with.</param>
-        /// <param name="compressedCounts">Memory storing the counts of non-zero elements at each index of the compressed dimension.</param>
-        /// <param name="indices">Memory storing the linearized index (excluding the compressed dimension) of non-zero elements.</param>
-        /// <param name="nonZeroCount">The number of valid entries (eg: non-zero values) in <paramref name="values"/> and <paramref name="indices"/>.</param>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the CompressedSparseTensor to create.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        public CompressedSparseTensor(Memory<T> values, Memory<int> compressedCounts, Memory<int> indices, int nonZeroCount, ReadOnlySpan<int> dimensions, bool reverseStride = false) : base(dimensions, reverseStride)
-        {
-            compressedDimension = reverseStride ? Rank - 1 : 0;
-            nonCompressedStrides = (int[])strides.Clone();
-            nonCompressedStrides[compressedDimension] = 0;
-            this.values = values;
-            this.compressedCounts = compressedCounts;
-            this.indices = indices;
-            this.nonZeroCount = nonZeroCount;
-        }
-
-        internal CompressedSparseTensor(Array fromArray, bool reverseStride = false) : base(fromArray, reverseStride)
-        {
-            nonZeroCount = 0;
-            compressedDimension = reverseStride ? Rank - 1 : 0;
-            nonCompressedStrides = (int[])strides.Clone();
-            nonCompressedStrides[compressedDimension] = 0;
-            var compressedDimensionLength = dimensions[compressedDimension];
-            compressedCounts = new int[compressedDimensionLength + 1];
-
-            int index = 0;
-            if (reverseStride)
-            {
-                // Array is always row-major
-                var sourceStrides = ArrayUtilities.GetStrides(dimensions);
-
-                foreach (T item in fromArray)
-                {
-                    if (!item!.Equals(Zero))
-                    {
-                        var destIndex = ArrayUtilities.TransformIndexByStrides(index, sourceStrides, false, strides);
-                        var compressedIndex = destIndex / strides[compressedDimension];
-                        var nonCompressedIndex = destIndex % strides[compressedDimension];
-
-                        SetAt(item, compressedIndex, nonCompressedIndex);
-                    }
-
-                    index++;
-                }
-            }
-            else
-            {
-                foreach (T item in fromArray)
-                {
-                    if (!item!.Equals(Zero))
-                    {
-                        var compressedIndex = index / strides[compressedDimension];
-                        var nonCompressedIndex = index % strides[compressedDimension];
-
-                        SetAt(item, compressedIndex, nonCompressedIndex);
-                    }
-
-                    index++;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Obtains the value at the specified indices
-        /// </summary>
-        /// <param name="indices">A span of integers that represent the indices specifying the position of the element to get.</param>
-        /// <returns>The value at the specified position in this Tensor.</returns>
-        public override T this[ReadOnlySpan<int> indices]
-        {
-            get
-            {
-                var compressedIndex = indices[compressedDimension];
-                var nonCompressedIndex = ArrayUtilities.GetIndex(nonCompressedStrides, indices);
-
-
-                if (TryFindIndex(compressedIndex, nonCompressedIndex, out int valueIndex))
-                {
-                    return values.Span[valueIndex];
-                }
-
-                return Zero;
-            }
-
-            set
-            {
-                var compressedIndex = indices[compressedDimension];
-                var nonCompressedIndex = ArrayUtilities.GetIndex(nonCompressedStrides, indices);
-
-                SetAt(value, compressedIndex, nonCompressedIndex);
-            }
-        }
-
-        /// <summary>
-        /// Gets the value at the specified index, where index is lineraized as a dot product between indices and strides.
-        /// </summary>
-        /// <param name="index">An integer index computed as a dot-product of indices.</param>
-        /// <returns>The value at the specified position in this Tensor.</returns>
-        public override T GetValue(int index)
-        {
-            var compressedDimensionStride = strides[compressedDimension];
-            Debug.Assert(compressedDimensionStride == strides.Max());
-
-            var compressedIndex = index / compressedDimensionStride;
-            var nonCompressedIndex = index % compressedDimensionStride;
-
-
-            if (TryFindIndex(compressedIndex, nonCompressedIndex, out int valueIndex))
-            {
-                return values.Span[valueIndex];
-            }
-
-            return Zero;
-        }
-
-        /// <summary>
-        /// Sets the value at the specified index, where index is a linearized version of n-dimension indices using strides.
-        /// </summary>
-        /// <param name="index">An integer index computed as a dot-product of indices.</param>
-        /// <param name="value">The new value to set at the specified position in this Tensor.</param>
-        public override void SetValue(int index, T value)
-        {
-            var compressedDimensionStride = strides[compressedDimension];
-            Debug.Assert(compressedDimensionStride == strides.Max());
-
-            var compressedIndex = index / compressedDimensionStride;
-            var nonCompressedIndex = index % compressedDimensionStride;
-
-            SetAt(value, compressedIndex, nonCompressedIndex);
-
-        }
-
-        /// <summary>
-        /// Gets the number of non-zero values this tensor can store without resizing.
-        /// </summary>
-        public int Capacity => values.Length;
-
-        /// <summary>
-        /// Get's the number on non-zero values currently being stored in this tensor.
-        /// </summary>
-        public int NonZeroCount => nonZeroCount;
-
-        /// <summary>
-        /// Memory storing non-zero values.
-        /// </summary>
-        public Memory<T> Values => values;
-
-        /// <summary>
-        /// Memory storing the counts of non-zero elements at each index of the compressed dimension.
-        /// </summary>
-        public Memory<int> CompressedCounts => compressedCounts;
-
-        /// <summary>
-        /// Memory storing the linearized index (excluding the compressed dimension) of non-zero elements.
-        /// </summary>
-        public Memory<int> Indices => indices;
-
-        private void EnsureCapacity(int min, int allocateIndex = -1)
-        {
-            if (values.Length < min)
-            {
-                var newCapacity = values.Length == 0 ? defaultCapacity : values.Length * 2;
-
-                if (newCapacity > Length)
-                {
-                    newCapacity = (int)Length;
-                }
-
-                if (newCapacity < min)
-                {
-                    newCapacity = min;
-                }
-
-                Memory<T> newValues = new T[newCapacity];
-                Memory<int> newIndices = new int[newCapacity];
-
-                if (nonZeroCount > 0)
-                {
-                    if (allocateIndex == -1)
-                    {
-                        var valuesSpan = values.Span.Slice(0, nonZeroCount);
-                        var indicesSpan = indices.Span.Slice(0, nonZeroCount);
-
-                        valuesSpan.CopyTo(newValues.Span);
-                        indicesSpan.CopyTo(newIndices.Span);
-                    }
-                    else
-                    {
-                        Debug.Assert(allocateIndex <= nonZeroCount);
-                        // leave a gap at allocateIndex
-
-                        // copy range before allocateIndex
-                        if (allocateIndex > 0)
-                        {
-                            var valuesSpan = values.Span.Slice(0, allocateIndex);
-                            var indicesSpan = indices.Span.Slice(0, allocateIndex);
-
-                            valuesSpan.CopyTo(newValues.Span);
-                            indicesSpan.CopyTo(newIndices.Span);
-                        }
-
-                        if (allocateIndex < nonZeroCount)
-                        {
-                            var valuesSpan = values.Span.Slice(allocateIndex, nonZeroCount - allocateIndex);
-                            var indicesSpan = indices.Span.Slice(allocateIndex, nonZeroCount - allocateIndex);
-
-                            var newValuesSpan = newValues.Span.Slice(allocateIndex + 1, nonZeroCount - allocateIndex);
-                            var newIndicesSpan = newIndices.Span.Slice(allocateIndex + 1, nonZeroCount - allocateIndex);
-
-                            valuesSpan.CopyTo(newValuesSpan);
-                            indicesSpan.CopyTo(newIndicesSpan);
-                        }
-                    }
-                }
-
-                values = newValues;
-                indices = newIndices;
-            }
-        }
-
-        private void InsertAt(int valueIndex, T value, int compressedIndex, int nonCompressedIndex)
-        {
-            Debug.Assert(valueIndex <= nonZeroCount);
-            Debug.Assert(compressedIndex < compressedCounts.Length - 1);
-
-            if (values.Length <= valueIndex)
-            {
-                // allocate a new array, leaving a gap
-                EnsureCapacity(valueIndex + 1, valueIndex);
-            }
-            else if (nonZeroCount != valueIndex)
-            {
-                // shift values to make a gap
-                values.Span.Slice(valueIndex, nonZeroCount - valueIndex).CopyTo(values.Span.Slice(valueIndex + 1));
-                indices.Span.Slice(valueIndex, nonZeroCount - valueIndex).CopyTo(indices.Span.Slice(valueIndex + 1));
-            }
-
-            values.Span[valueIndex] = value;
-            indices.Span[valueIndex] = nonCompressedIndex;
-
-            var compressedCountsSpan = compressedCounts.Span.Slice(compressedIndex + 1);
-            for (int i = 0; i < compressedCountsSpan.Length; i++)
-            {
-                compressedCountsSpan[i]++;
-            }
-            nonZeroCount++;
-        }
-
-        private void RemoveAt(int valueIndex, int compressedIndex)
-        {
-            Debug.Assert(valueIndex < nonZeroCount);
-            Debug.Assert(compressedIndex < compressedCounts.Length - 1);
-
-            // shift values to close the gap
-            values.Span.Slice(valueIndex + 1, nonZeroCount - valueIndex - 1).CopyTo(values.Span.Slice(valueIndex));
-            indices.Span.Slice(valueIndex + 1, nonZeroCount - valueIndex - 1).CopyTo(indices.Span.Slice(valueIndex));
-
-            var compressedCountsSpan = compressedCounts.Span.Slice(compressedIndex + 1);
-            for (int i = 0; i < compressedCountsSpan.Length; i++)
-            {
-                compressedCountsSpan[i]--;
-            }
-            nonZeroCount--;
-        }
-
-        private void SetAt(T value, int compressedIndex, int nonCompressedIndex)
-        {
-            bool isZero = value!.Equals(Zero);
-
-            if (TryFindIndex(compressedIndex, nonCompressedIndex, out int valueIndex))
-            {
-                if (isZero)
-                {
-                    RemoveAt(valueIndex, compressedIndex);
-                }
-                else
-                {
-                    values.Span[valueIndex] = value;
-                    indices.Span[valueIndex] = nonCompressedIndex;
-                }
-            }
-            else if (!isZero)
-            {
-                InsertAt(valueIndex, value, compressedIndex, nonCompressedIndex);
-            }
-        }
-
-        /// <summary>
-        /// Trys to find the place to store a value
-        /// </summary>
-        /// <param name="compressedIndex"></param>
-        /// <param name="nonCompressedIndex"></param>
-        /// <param name="valueIndex"></param>
-        /// <returns>True if element is found at specific index, false if no specific index is found and insertion point is returned</returns>
-        private bool TryFindIndex(int compressedIndex, int nonCompressedIndex, out int valueIndex)
-        {
-            if (nonZeroCount == 0)
-            {
-                valueIndex = 0;
-                return false;
-            }
-
-            Debug.Assert(compressedIndex < compressedCounts.Length - 1);
-
-            var compressedCountsSpan = compressedCounts.Span;
-            var lowerValueIndex = compressedCountsSpan[compressedIndex];
-            var upperValueIndex = compressedCountsSpan[compressedIndex + 1];
-            var indicesSpan = indices.Span;
-
-            // could be a faster search
-            for (valueIndex = lowerValueIndex; valueIndex < upperValueIndex; valueIndex++)
-            {
-                if (indicesSpan[valueIndex] == nonCompressedIndex)
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Creates a shallow copy of this tensor, with new backing storage.
-        /// </summary>
-        /// <returns>A shallow copy of this tensor.</returns>
-        public override Tensor<T> Clone()
-        {
-            return new CompressedSparseTensor<T>(values.ToArray(), compressedCounts.ToArray(), indices.ToArray(), nonZeroCount, dimensions, IsReversedStride);
-        }
-
-        /// <summary>
-        /// Creates a new Tensor of a different type with the specified dimensions and the same layout as this tensor with elements initialized to their default value.
-        /// </summary>
-        /// <typeparam name="TResult">Type contained in the returned Tensor.</typeparam>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the CompressedSparseTensor to create.</param>
-        /// <returns>A new tensor with the same layout as this tensor but different type and dimensions.</returns>
-        public override Tensor<TResult> CloneEmpty<TResult>(ReadOnlySpan<int> dimensions)
-        {
-            return new CompressedSparseTensor<TResult>(dimensions, IsReversedStride);
-        }
-
-        /// <summary>
-        /// Reshapes the current tensor to new dimensions. Unlike other Tensor implementations, CompressedSparseTensor&lt;T&gt; must allocate new backing storage to represent a reshaped Tensor.
-        /// </summary>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the CompressedSparseTensor to create.</param>
-        /// <returns>A new tensor that reinterprets the content of this tensor to new dimensions (assuming the same linear index for each element).</returns>
-        public override Tensor<T> Reshape(ReadOnlySpan<int> dimensions)
-        {
-            // reshape currently has shallow semantics which are not compatible with the backing storage for CompressedSparseTensor
-            // which bakes in information about dimensions (compressedCounts and indices)
-
-            var newCompressedDimension = IsReversedStride ? dimensions.Length - 1 : 0;
-            var newCompressedDimensionLength = dimensions[newCompressedDimension];
-            var newCompressedDimensionStride = (int)(Length / newCompressedDimensionLength);
-
-            var newValues = (T[])values.ToArray();
-            var newCompressedCounts = new int[newCompressedDimensionLength + 1];
-            var newIndices = new int[indices.Length];
-
-            var compressedIndex = 0;
-
-            var compressedCountsSpan = compressedCounts.Span;
-            var indicesSpan = indices.Span.Slice(0, nonZeroCount);
-            for (int valueIndex = 0; valueIndex < indicesSpan.Length; valueIndex++)
-            {
-                while (valueIndex >= compressedCountsSpan[compressedIndex + 1])
-                {
-                    compressedIndex++;
-                    Debug.Assert(compressedIndex < compressedCounts.Length);
-                }
-
-                var currentIndex = indicesSpan[valueIndex] + compressedIndex * strides[compressedDimension];
-
-                newIndices[valueIndex] = currentIndex % newCompressedDimensionStride;
-
-                var newCompressedIndex = currentIndex / newCompressedDimensionStride;
-                newCompressedCounts[newCompressedIndex + 1] = valueIndex + 1;
-            }
-
-            return new CompressedSparseTensor<T>(newValues, newCompressedCounts, newIndices, nonZeroCount, dimensions, IsReversedStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this tensor as a DenseTensor&lt;T&gt;.
-        /// </summary>
-        /// <returns>A copy of this tensor as a DenseTensor&lt;T&gt;</returns>
-        public override DenseTensor<T> ToDenseTensor()
-        {
-            var denseTensor = new DenseTensor<T>(Dimensions, reverseStride: IsReversedStride);
-
-            var compressedIndex = 0;
-
-            var compressedCountsSpan = compressedCounts.Span;
-            var indicesSpan = indices.Span.Slice(0, nonZeroCount);
-            var valuesSpan = values.Span.Slice(0, nonZeroCount);
-            for (int valueIndex = 0; valueIndex < valuesSpan.Length; valueIndex++)
-            {
-                while (valueIndex >= compressedCountsSpan[compressedIndex + 1])
-                {
-                    compressedIndex++;
-                    Debug.Assert(compressedIndex < compressedCounts.Length);
-                }
-
-                var index = indicesSpan[valueIndex] + compressedIndex * strides[compressedDimension];
-
-                denseTensor.SetValue(index, valuesSpan[valueIndex]);
-            }
-
-            return denseTensor;
-        }
-
-        /// <summary>
-        /// Creates a copy of this tensor as a new CompressedSparseTensor&lt;T&gt; eliminating any unused space in the backing storage.
-        /// </summary>
-        /// <returns>A copy of this tensor as a CompressedSparseTensor&lt;T&gt;.</returns>
-        public override CompressedSparseTensor<T> ToCompressedSparseTensor()
-        {
-            // Create a copy of the backing storage, eliminating any unused space.
-            var newValues = values.Slice(0, nonZeroCount).ToArray();
-            var newIndices = indices.Slice(0, nonZeroCount).ToArray();
-
-            return new CompressedSparseTensor<T>(newValues, compressedCounts.ToArray(), newIndices, nonZeroCount, dimensions, IsReversedStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this tensor as a SparseTensor&lt;T&gt;.
-        /// </summary>
-        /// <returns>A copy of this tensor as a SparseTensor&lt;T&gt;.</returns>
-        public override SparseTensor<T> ToSparseTensor()
-        {
-            var sparseTensor = new SparseTensor<T>(dimensions, capacity: NonZeroCount, reverseStride: IsReversedStride);
-
-            var compressedIndex = 0;
-
-            var compressedCountsSpan = compressedCounts.Span;
-            var indicesSpan = indices.Span.Slice(0, nonZeroCount);
-            var valuesSpan = values.Span.Slice(0, nonZeroCount);
-            for (int valueIndex = 0; valueIndex < valuesSpan.Length; valueIndex++)
-            {
-                while (valueIndex >= compressedCountsSpan[compressedIndex + 1])
-                {
-                    compressedIndex++;
-                    Debug.Assert(compressedIndex < compressedCounts.Length);
-                }
-
-                var index = indicesSpan[valueIndex] + compressedIndex * strides[compressedDimension];
-
-                sparseTensor.SetValue(index, valuesSpan[valueIndex]);
-            }
-
-            return sparseTensor;
-        }
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/DenseTensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/DenseTensor.cs
deleted file mode 100644
index 5f8715be3d18c8..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/DenseTensor.cs
+++ /dev/null
@@ -1,178 +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.Runtime.InteropServices;
-
-namespace System.Numerics.Tensors
-{
-    /// <summary>
-    /// Represents a multi-dimensional collection of objects of type T that can be accessed by indices.  DenseTensor stores values in a contiguous sequential block of memory where all values are represented.
-    /// </summary>
-    /// <typeparam name="T">type contained within the Tensor.  Typically a value type such as int, double, float, etc.</typeparam>
-    public class DenseTensor<T> : Tensor<T>
-    {
-        private readonly Memory<T> memory;
-
-        internal DenseTensor(Array fromArray, bool reverseStride = false) : base(fromArray, reverseStride)
-        {
-            // copy initial array
-            var backingArray = new T[fromArray.Length];
-
-            int index = 0;
-            if (reverseStride)
-            {
-                // Array is always row-major
-                var sourceStrides = ArrayUtilities.GetStrides(dimensions);
-
-                foreach (var item in fromArray)
-                {
-                    var destIndex = ArrayUtilities.TransformIndexByStrides(index++, sourceStrides, false, strides);
-                    backingArray[destIndex] = (T)item!;
-                }
-            }
-            else
-            {
-                foreach (var item in fromArray)
-                {
-                    backingArray[index++] = (T)item!;
-                }
-            }
-            memory = backingArray;
-        }
-
-        /// <summary>
-        /// Initializes a rank-1 Tensor using the specified <paramref name="length"/>.
-        /// </summary>
-        /// <param name="length">Size of the 1-dimensional tensor</param>
-        public DenseTensor(int length) : base(length)
-        {
-            memory = new T[length];
-        }
-
-        /// <summary>
-        /// Initializes a rank-n Tensor using the dimensions specified in <paramref name="dimensions"/>.
-        /// </summary>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the DenseTensor to create.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        public DenseTensor(ReadOnlySpan<int> dimensions, bool reverseStride = false) : base(dimensions, reverseStride)
-        {
-            memory = new T[Length];
-        }
-
-        /// <summary>
-        /// Constructs a new DenseTensor of the specified dimensions, wrapping existing backing memory for the contents.
-        /// </summary>
-        /// <param name="memory"></param>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the DenseTensor to create.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        public DenseTensor(Memory<T> memory, ReadOnlySpan<int> dimensions, bool reverseStride = false) : base(dimensions, reverseStride)
-        {
-            this.memory = memory;
-
-            if (Length != memory.Length)
-            {
-                throw new ArgumentException(SR.Format(SR.LengthMustMatch, nameof(memory), memory.Length, nameof(dimensions), Length));
-            }
-        }
-
-        /// <summary>
-        /// Memory storing backing values of this tensor.
-        /// </summary>
-        public Memory<T> Buffer => memory;
-
-        /// <summary>
-        /// Gets the value at the specified index, where index is a linearized version of n-dimension indices using strides.
-        /// </summary>
-        /// <param name="index">An integer index computed as a dot-product of indices.</param>
-        /// <returns>The value at the specified position in this Tensor.</returns>
-        public override T GetValue(int index)
-        {
-            return Buffer.Span[index];
-        }
-
-        /// <summary>
-        /// Sets the value at the specified index, where index is a linearized version of n-dimension indices using strides.
-        /// </summary>
-        /// <param name="index">An integer index computed as a dot-product of indices.</param>
-        /// <param name="value">The new value to set at the specified position in this Tensor.</param>
-        public override void SetValue(int index, T value)
-        {
-            Buffer.Span[index] = value;
-        }
-
-        protected override void CopyTo(T[] array, int arrayIndex)
-        {
-            if (array is null)
-            {
-                throw new ArgumentNullException(nameof(array));
-            }
-
-            if (array.Length < arrayIndex + Length)
-            {
-                throw new ArgumentException(SR.NumberGreaterThenAvailableSpace, nameof(array));
-            }
-
-            Buffer.Span.CopyTo(array.AsSpan(arrayIndex));
-        }
-
-        protected override int IndexOf(T item)
-        {
-            // TODO: use Span.IndexOf when/if it removes the IEquatable type constraint
-            if (MemoryMarshal.TryGetArray<T>(Buffer, out var arraySegment))
-            {
-                var result = Array.IndexOf(arraySegment.Array!, item, arraySegment.Offset, arraySegment.Count);
-                if (result != -1)
-                {
-                    result -= arraySegment.Offset;
-                }
-                return result;
-            }
-            else
-            {
-                return base.IndexOf(item);
-            }
-        }
-
-        /// <summary>
-        /// Creates a shallow copy of this tensor, with new backing storage.
-        /// </summary>
-        /// <returns>A shallow copy of this tensor.</returns>
-        public override Tensor<T> Clone()
-        {
-            return new DenseTensor<T>(Buffer.ToArray(), dimensions, IsReversedStride);
-        }
-
-        /// <summary>
-        /// Creates a new Tensor of a different type with the specified dimensions and the same layout as this tensor with elements initialized to their default value.
-        /// </summary>
-        /// <typeparam name="TResult">Type contained in the returned Tensor.</typeparam>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the DenseTensor to create.</param>
-        /// <returns>A new tensor with the same layout as this tensor but different type and dimensions.</returns>
-        public override Tensor<TResult> CloneEmpty<TResult>(ReadOnlySpan<int> dimensions)
-        {
-            return new DenseTensor<TResult>(dimensions, IsReversedStride);
-        }
-
-        /// <summary>
-        /// Reshapes the current tensor to new dimensions, using the same backing storage.
-        /// </summary>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the DenseTensor to create.</param>
-        /// <returns>A new tensor that reinterprets backing Buffer of this tensor with different dimensions.</returns>
-        public override Tensor<T> Reshape(ReadOnlySpan<int> dimensions)
-        {
-            if (dimensions.Length == 0)
-            {
-                throw new ArgumentException(SR.DimensionsMustContainElements, nameof(dimensions));
-            }
-
-            var newSize = ArrayUtilities.GetProduct(dimensions);
-
-            if (newSize != Length)
-            {
-                throw new ArgumentException(SR.Format(SR.CannotReshapeArrayDueToMismatchInLengths, Length, newSize), nameof(dimensions));
-            }
-
-            return new DenseTensor<T>(Buffer, dimensions, IsReversedStride);
-        }
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/SparseTensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/SparseTensor.cs
deleted file mode 100644
index 83948a0b918b7d..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/SparseTensor.cs
+++ /dev/null
@@ -1,177 +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.Collections.Generic;
-
-namespace System.Numerics.Tensors
-{
-    /// <summary>
-    /// Represents a multi-dimensional collection of objects of type T that can be accessed by indices.  Unlike other Tensor&lt;T&gt; implementations SparseTensor&lt;T&gt; does not expose its backing storage.  It is meant as an intermediate to be used to build other Tensors, such as CompressedSparseTensor.  Unlike CompressedSparseTensor where insertions are O(n), insertions to SparseTensor&lt;T&gt; are nominally O(1).
-    /// </summary>
-    /// <typeparam name="T">type contained within the Tensor.  Typically a value type such as int, double, float, etc.</typeparam>
-    public class SparseTensor<T> : Tensor<T>
-    {
-        private readonly Dictionary<int, T> values;
-        /// <summary>
-        /// Constructs a new SparseTensor of the specified dimensions, initial capacity, and stride ordering.
-        /// </summary>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the SparseTensor to create.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        /// <param name="capacity">The number of non-zero values this tensor can store without resizing.</param>
-        public SparseTensor(ReadOnlySpan<int> dimensions, bool reverseStride = false, int capacity = 0) : base(dimensions, reverseStride)
-        {
-            values = new Dictionary<int, T>(capacity);
-        }
-
-        internal SparseTensor(Dictionary<int, T> values, ReadOnlySpan<int> dimensions, bool reverseStride = false) : base(dimensions, reverseStride)
-        {
-            this.values = values;
-        }
-
-        internal SparseTensor(Array fromArray, bool reverseStride = false) : base(fromArray, reverseStride)
-        {
-            values = new Dictionary<int, T>(fromArray.Length);
-
-            int index = 0;
-            if (reverseStride)
-            {
-                // Array is always row-major
-                var sourceStrides = ArrayUtilities.GetStrides(dimensions);
-
-                foreach (T item in fromArray)
-                {
-                    if (!item!.Equals(Zero))
-                    {
-                        var destIndex = ArrayUtilities.TransformIndexByStrides(index, sourceStrides, false, strides);
-                        values[destIndex] = item;
-                    }
-
-                    index++;
-                }
-            }
-            else
-            {
-                foreach (T item in fromArray)
-                {
-                    if (!item!.Equals(Zero))
-                    {
-                        values[index] = item;
-                    }
-
-                    index++;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Gets the value at the specified index, where index is a linearized version of n-dimension indices using strides.
-        /// </summary>
-        /// <param name="index">An integer index computed as a dot-product of indices.</param>
-        /// <returns>The value at the specified position in this Tensor.</returns>
-        public override T GetValue(int index)
-        {
-
-            if (!values.TryGetValue(index, out T? value))
-            {
-                value = Zero;
-            }
-
-            return value;
-        }
-
-        /// <summary>
-        /// Sets the value at the specified index, where index is a linearized version of n-dimension indices using strides.
-        /// </summary>
-        /// <param name="index">An integer index computed as a dot-product of indices.</param>
-        /// <param name="value">The new value to set at the specified position in this Tensor.</param>
-        public override void SetValue(int index, T value)
-        {
-            if (value!.Equals(Zero))
-            {
-                values.Remove(index);
-            }
-            else
-            {
-                values[index] = value;
-            }
-        }
-
-        /// <summary>
-        /// Get's the number on non-zero values currently being stored in this tensor.
-        /// </summary>
-        public int NonZeroCount => values.Count;
-
-        /// <summary>
-        /// Creates a shallow copy of this tensor, with new backing storage.
-        /// </summary>
-        /// <returns>A shallow copy of this tensor.</returns>
-        public override Tensor<T> Clone()
-        {
-            var valueCopy = new Dictionary<int, T>(values);
-            return new SparseTensor<T>(valueCopy, dimensions, IsReversedStride);
-        }
-
-        /// <summary>
-        /// Creates a new Tensor of a different type with the specified dimensions and the same layout as this tensor with elements initialized to their default value.
-        /// </summary>
-        /// <typeparam name="TResult">Type contained in the returned Tensor.</typeparam>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the SparseTensor to create.</param>
-        /// <returns>A new tensor with the same layout as this tensor but different type and dimensions.</returns>
-        public override Tensor<TResult> CloneEmpty<TResult>(ReadOnlySpan<int> dimensions)
-        {
-            return new SparseTensor<TResult>(dimensions, IsReversedStride);
-        }
-
-        /// <summary>
-        /// Reshapes the current tensor to new dimensions, using the same backing storage.
-        /// </summary>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the SparseTensor to create.</param>
-        /// <returns>A new tensor that reinterprets backing storage of this tensor with different dimensions.</returns>
-        public override Tensor<T> Reshape(ReadOnlySpan<int> dimensions)
-        {
-            return new SparseTensor<T>(values, dimensions, IsReversedStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this tensor as a DenseTensor&lt;T&gt;.
-        /// </summary>
-        /// <returns>A copy of this tensor as a DenseTensor&lt;T&gt;</returns>
-        public override DenseTensor<T> ToDenseTensor()
-        {
-            var denseTensor = new DenseTensor<T>(Dimensions, reverseStride: IsReversedStride);
-
-            // only set non-zero values
-            foreach (var pair in values)
-            {
-                denseTensor.SetValue(pair.Key, pair.Value);
-            }
-
-            return denseTensor;
-        }
-
-        /// <summary>
-        /// Creates a copy of this tensor as a new SparseTensor&lt;T&gt; eliminating any unused space in the backing storage.
-        /// </summary>
-        /// <returns>A copy of this tensor as a SparseTensor&lt;T&gt; eliminated any usused space in the backing storage.</returns>
-        public override SparseTensor<T> ToSparseTensor()
-        {
-            var valueCopy = new Dictionary<int, T>(values);
-            return new SparseTensor<T>(valueCopy, dimensions, IsReversedStride);
-        }
-
-        /// <summary>
-        /// Creates a copy of this tensor as a CompressedSparseTensor&lt;T&gt;.
-        /// </summary>
-        /// <returns>A copy of this tensor as a CompressedSparseTensor&lt;T&gt;.</returns>
-        public override CompressedSparseTensor<T> ToCompressedSparseTensor()
-        {
-            var compressedSparseTensor = new CompressedSparseTensor<T>(dimensions, capacity: NonZeroCount, reverseStride: IsReversedStride);
-
-            foreach (var pair in values)
-            {
-                compressedSparseTensor.SetValue(pair.Key, pair.Value);
-            }
-            return compressedSparseTensor;
-        }
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/Tensor.cs
deleted file mode 100644
index f63547682dd24b..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/Tensor.cs
+++ /dev/null
@@ -1,1365 +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.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Text;
-
-namespace System.Numerics.Tensors
-{
-    /// <summary>
-    /// Various methods for creating and manipulating Tensor&lt;T&gt;
-    /// </summary>
-    public static partial class Tensor
-    {
-        /// <summary>
-        /// Creates an identity tensor of the specified size.  An identity tensor is a two dimensional tensor with 1s in the diagonal.
-        /// </summary>
-        /// <typeparam name="T">type contained within the Tensor.  Typically a value type such as int, double, float, etc.</typeparam>
-        /// <param name="size">Width and height of the identity tensor to create.</param>
-        /// <returns>a <paramref name="size"/> by <paramref name="size"/> with 1s along the diagonal and zeros elsewhere.</returns>
-        public static Tensor<T> CreateIdentity<T>(int size)
-        {
-            return CreateIdentity(size, false, Tensor<T>.One);
-        }
-
-        /// <summary>
-        /// Creates an identity tensor of the specified size and layout (row vs column major).  An identity tensor is a two dimensional tensor with 1s in the diagonal.
-        /// </summary>
-        /// <typeparam name="T">type contained within the Tensor.  Typically a value type such as int, double, float, etc.</typeparam>
-        /// <param name="size">Width and height of the identity tensor to create.</param>
-        /// <param name="columMajor">>False to indicate that the first dimension is most minor (closest) and the last dimension is most major (farthest): row-major.  True to indicate that the last dimension is most minor (closest together) and the first dimension is most major (farthest apart): column-major.</param>
-        /// <returns>a <paramref name="size"/> by <paramref name="size"/> with 1s along the diagonal and zeros elsewhere.</returns>
-        public static Tensor<T> CreateIdentity<T>(int size, bool columMajor)
-        {
-            return CreateIdentity(size, columMajor, Tensor<T>.One);
-        }
-
-        /// <summary>
-        /// Creates an identity tensor of the specified size and layout (row vs column major) using the specified one value.  An identity tensor is a two dimensional tensor with 1s in the diagonal.  This may be used in case T is a type that doesn't have a known 1 value.
-        /// </summary>
-        /// <typeparam name="T">type contained within the Tensor.  Typically a value type such as int, double, float, etc.</typeparam>
-        /// <param name="size">Width and height of the identity tensor to create.</param>
-        /// <param name="columMajor">>False to indicate that the first dimension is most minor (closest) and the last dimension is most major (farthest): row-major.  True to indicate that the last dimension is most minor (closest together) and the first dimension is most major (farthest apart): column-major.</param>
-        /// <param name="oneValue">Value of <typeparamref name="T"/> that is used along the diagonal.</param>
-        /// <returns>a <paramref name="size"/> by <paramref name="size"/> with 1s along the diagonal and zeros elsewhere.</returns>
-        public static Tensor<T> CreateIdentity<T>(int size, bool columMajor, T oneValue)
-        {
-            Span<int> dimensions = stackalloc int[2];
-            dimensions[0] = dimensions[1] = size;
-
-            var result = new DenseTensor<T>(dimensions, columMajor);
-
-            for (int i = 0; i < size; i++)
-            {
-                result.SetValue(i * size + i, oneValue);
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Creates a n+1-rank tensor using the specified n-rank diagonal.  Values not on the diagonal will be filled with zeros.
-        /// </summary>
-        /// <typeparam name="T">type contained within the Tensor.  Typically a value type such as int, double, float, etc.</typeparam>
-        /// <param name="diagonal">Tensor representing the diagonal to build the new tensor from.</param>
-        /// <returns>A new tensor of the same layout and order as <paramref name="diagonal"/> of one higher rank, with the values of <paramref name="diagonal"/> along the diagonal and zeros elsewhere.</returns>
-        public static Tensor<T> CreateFromDiagonal<T>(Tensor<T> diagonal)
-        {
-            return CreateFromDiagonal(diagonal, 0);
-        }
-
-        /// <summary>
-        /// Creates a n+1-dimension tensor using the specified n-dimension diagonal at the specified offset from the center.  Values not on the diagonal will be filled with zeros.
-        /// </summary>
-        /// <typeparam name="T">type contained within the Tensor.  Typically a value type such as int, double, float, etc.</typeparam>
-        /// <param name="diagonal">Tensor representing the diagonal to build the new tensor from.</param>
-        /// <param name="offset">Offset of diagonal to set in returned tensor.  0 for the main diagonal, less than zero for diagonals below, greater than zero from diagonals above.</param>
-        /// <returns>A new tensor of the same layout and order as <paramref name="diagonal"/> of one higher rank, with the values of <paramref name="diagonal"/> along the specified diagonal and zeros elsewhere.</returns>
-        public static Tensor<T> CreateFromDiagonal<T>(Tensor<T> diagonal, int offset)
-        {
-            if (diagonal.Rank < 1)
-            {
-                throw new ArgumentException(SR.Format(SR.MustHaveAtLeastOneDimension, nameof(diagonal)), nameof(diagonal));
-            }
-
-            int diagonalLength = diagonal.dimensions[0];
-
-            // TODO: allow specification of axis1 and axis2?
-            var rank = diagonal.dimensions.Length + 1;
-            Span<int> dimensions = rank < ArrayUtilities.StackallocMax ? stackalloc int[rank] : new int[rank];
-
-            // assume square
-            var axisLength = diagonalLength + Math.Abs(offset);
-            dimensions[0] = dimensions[1] = axisLength;
-
-            for (int i = 1; i < diagonal.dimensions.Length; i++)
-            {
-                dimensions[i + 1] = diagonal.dimensions[i];
-            }
-
-            var result = diagonal.CloneEmpty(dimensions);
-
-            var sizePerDiagonal = diagonal.Length / diagonalLength;
-
-            var diagProjectionStride = diagonal.IsReversedStride && diagonal.Rank > 1 ? diagonal.strides[1] : 1;
-            var resultProjectionStride = result.IsReversedStride && result.Rank > 2 ? result.strides[2] : 1;
-
-            for (int diagIndex = 0; diagIndex < diagonalLength; diagIndex++)
-            {
-                var resultIndex0 = offset < 0 ? diagIndex - offset : diagIndex;
-                var resultIndex1 = offset > 0 ? diagIndex + offset : diagIndex;
-
-                var resultBase = resultIndex0 * result.strides[0] + resultIndex1 * result.strides[1];
-                var diagBase = diagIndex * diagonal.strides[0];
-
-                for (int diagProjectionOffset = 0; diagProjectionOffset < sizePerDiagonal; diagProjectionOffset++)
-                {
-                    result.SetValue(resultBase + diagProjectionOffset * resultProjectionStride,
-                        diagonal.GetValue(diagBase + diagProjectionOffset * diagProjectionStride));
-                }
-            }
-
-            return result;
-        }
-    }
-
-    /// <summary>
-    /// Represents a multi-dimensional collection of objects of type T that can be accessed by indices.
-    /// </summary>
-    /// <typeparam name="T">type contained within the Tensor.  Typically a value type such as int, double, float, etc.</typeparam>
-    [DebuggerDisplay("{GetArrayString(false)}")]
-    // When we cross-compile for frameworks that expose ICloneable this must implement ICloneable as well.
-    public abstract class Tensor<T> : IList, IList<T>, IReadOnlyList<T>, IStructuralComparable, IStructuralEquatable
-    {
-        internal static T Zero
-        {
-            get
-            {
-                if (typeof(T) == typeof(bool))
-                {
-                    return (T)(object)(false);
-                }
-                else if (typeof(T) == typeof(byte))
-                {
-                    return (T)(object)(byte)(0);
-                }
-                else if (typeof(T) == typeof(char))
-                {
-                    return (T)(object)(char)(0);
-                }
-                else if (typeof(T) == typeof(decimal))
-                {
-                    return (T)(object)(decimal)(0);
-                }
-                else if (typeof(T) == typeof(double))
-                {
-                    return (T)(object)(double)(0);
-                }
-                else if (typeof(T) == typeof(float))
-                {
-                    return (T)(object)(float)(0);
-                }
-                else if (typeof(T) == typeof(int))
-                {
-                    return (T)(object)(int)(0);
-                }
-                else if (typeof(T) == typeof(long))
-                {
-                    return (T)(object)(long)(0);
-                }
-                else if (typeof(T) == typeof(sbyte))
-                {
-                    return (T)(object)(sbyte)(0);
-                }
-                else if (typeof(T) == typeof(short))
-                {
-                    return (T)(object)(short)(0);
-                }
-                else if (typeof(T) == typeof(uint))
-                {
-                    return (T)(object)(uint)(0);
-                }
-                else if (typeof(T) == typeof(ulong))
-                {
-                    return (T)(object)(ulong)(0);
-                }
-                else if (typeof(T) == typeof(ushort))
-                {
-                    return (T)(object)(ushort)(0);
-                }
-
-                throw new NotSupportedException();
-            }
-        }
-
-        internal static T One
-        {
-            get
-            {
-                if (typeof(T) == typeof(bool))
-                {
-                    return (T)(object)(true);
-                }
-                else if (typeof(T) == typeof(byte))
-                {
-                    return (T)(object)(byte)(1);
-                }
-                else if (typeof(T) == typeof(char))
-                {
-                    return (T)(object)(char)(1);
-                }
-                else if (typeof(T) == typeof(decimal))
-                {
-                    return (T)(object)(decimal)(1);
-                }
-                else if (typeof(T) == typeof(double))
-                {
-                    return (T)(object)(double)(1);
-                }
-                else if (typeof(T) == typeof(float))
-                {
-                    return (T)(object)(float)(1);
-                }
-                else if (typeof(T) == typeof(int))
-                {
-                    return (T)(object)(int)(1);
-                }
-                else if (typeof(T) == typeof(long))
-                {
-                    return (T)(object)(long)(1);
-                }
-                else if (typeof(T) == typeof(sbyte))
-                {
-                    return (T)(object)(sbyte)(1);
-                }
-                else if (typeof(T) == typeof(short))
-                {
-                    return (T)(object)(short)(1);
-                }
-                else if (typeof(T) == typeof(uint))
-                {
-                    return (T)(object)(uint)(1);
-                }
-                else if (typeof(T) == typeof(ulong))
-                {
-                    return (T)(object)(ulong)(1);
-                }
-                else if (typeof(T) == typeof(ushort))
-                {
-                    return (T)(object)(ushort)(1);
-                }
-
-                throw new NotSupportedException();
-            }
-        }
-
-        internal readonly int[] dimensions;
-        internal readonly int[] strides;
-        private readonly bool isReversedStride;
-
-        private readonly long length;
-
-        /// <summary>
-        /// Initialize a 1-dimensional tensor of the specified length
-        /// </summary>
-        /// <param name="length">Size of the 1-dimensional tensor</param>
-        protected Tensor(int length)
-        {
-            dimensions = new[] { length };
-            strides = new[] { 1 };
-            isReversedStride = false;
-            this.length = length;
-        }
-
-        /// <summary>
-        /// Initialize an n-dimensional tensor with the specified dimensions and layout.  ReverseStride=true gives a stride of 1-element witdth to the first dimension (0).  ReverseStride=false gives a stride of 1-element width to the last dimension (n-1).
-        /// </summary>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the Tensor to create.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        protected Tensor(ReadOnlySpan<int> dimensions, bool reverseStride)
-        {
-            if (dimensions.Length == 0)
-            {
-                throw new ArgumentException(SR.DimensionsMustContainElements, nameof(dimensions));
-            }
-
-            this.dimensions = new int[dimensions.Length];
-            long size = 1;
-            for (int i = 0; i < dimensions.Length; i++)
-            {
-                if (dimensions[i] < 1)
-                {
-                    throw new ArgumentOutOfRangeException(nameof(dimensions), SR.DimensionsMustBePositiveAndNonZero);
-                }
-                this.dimensions[i] = dimensions[i];
-                size *= dimensions[i];
-            }
-
-            strides = ArrayUtilities.GetStrides(dimensions, reverseStride);
-            isReversedStride = reverseStride;
-
-            length = size;
-        }
-
-        /// <summary>
-        /// Initializes tensor with same dimensions as array, content of array is ignored.  ReverseStride=true gives a stride of 1-element witdth to the first dimension (0).  ReverseStride=false gives a stride of 1-element width to the last dimension (n-1).
-        /// </summary>
-        /// <param name="fromArray">Array from which to derive dimensions.</param>
-        /// <param name="reverseStride">False (default) to indicate that the first dimension is most major (farthest apart) and the last dimension is most minor (closest together): akin to row-major in a rank-2 tensor.  True to indicate that the last dimension is most major (farthest apart) and the first dimension is most minor (closest together): akin to column-major in a rank-2 tensor.</param>
-        protected Tensor(Array fromArray, bool reverseStride)
-        {
-            if (fromArray is null)
-            {
-                throw new ArgumentNullException(nameof(fromArray));
-            }
-
-            if (fromArray.Rank == 0)
-            {
-                throw new ArgumentException(SR.ArrayMustContainElements, nameof(fromArray));
-            }
-
-            dimensions = new int[fromArray.Rank];
-            long size = 1;
-            for (int i = 0; i < dimensions.Length; i++)
-            {
-                dimensions[i] = fromArray.GetLength(i);
-                size *= dimensions[i];
-            }
-
-            strides = ArrayUtilities.GetStrides(dimensions, reverseStride);
-            isReversedStride = reverseStride;
-
-            length = size;
-        }
-
-        /// <summary>
-        /// Total length of the Tensor.
-        /// </summary>
-        public long Length => length;
-
-        /// <summary>
-        /// Rank of the tensor: number of dimensions.
-        /// </summary>
-        public int Rank => dimensions.Length;
-
-        /// <summary>
-        /// True if strides are reversed (AKA Column-major)
-        /// </summary>
-        public bool IsReversedStride => isReversedStride;
-
-        /// <summary>
-        /// Returns a readonly view of the dimensions of this tensor.
-        /// </summary>
-        public ReadOnlySpan<int> Dimensions => dimensions;
-
-        /// <summary>
-        /// Returns a readonly view of the strides of this tensor.
-        /// </summary>
-        public ReadOnlySpan<int> Strides => strides;
-
-        /// <summary>
-        /// Sets all elements in Tensor to <paramref name="value"/>.
-        /// </summary>
-        /// <param name="value">Value to fill</param>
-        public virtual void Fill(T value)
-        {
-            for (int i = 0; i < Length; i++)
-            {
-                SetValue(i, value);
-            }
-        }
-
-        /// <summary>
-        /// Creates a shallow copy of this tensor, with new backing storage.
-        /// </summary>
-        /// <returns>A shallow copy of this tensor.</returns>
-        public abstract Tensor<T> Clone();
-
-        /// <summary>
-        /// Creates a new Tensor with the same layout and dimensions as this tensor with elements initialized to their default value.
-        /// </summary>
-        /// <returns>A new Tensor with the same layout and dimensions as this tensor with elements initialized to their default value.</returns>
-        public virtual Tensor<T> CloneEmpty()
-        {
-            return CloneEmpty<T>(dimensions);
-        }
-
-        /// <summary>
-        /// Creates a new Tensor with the specified dimensions and the same layout as this tensor with elements initialized to their default value.
-        /// </summary>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the DenseTensor to create.</param>
-        /// <returns>A new Tensor with the same layout as this tensor and specified <paramref name="dimensions"/> with elements initialized to their default value.</returns>
-        public virtual Tensor<T> CloneEmpty(ReadOnlySpan<int> dimensions)
-        {
-            return CloneEmpty<T>(dimensions);
-        }
-
-        /// <summary>
-        /// Creates a new Tensor of a different type with the same layout and size as this tensor with elements initialized to their default value.
-        /// </summary>
-        /// <typeparam name="TResult">Type contained within the new Tensor.  Typically a value type such as int, double, float, etc.</typeparam>
-        /// <returns>A new Tensor with the same layout and dimensions as this tensor with elements of <typeparamref name="TResult"/> type initialized to their default value.</returns>
-        public virtual Tensor<TResult> CloneEmpty<TResult>()
-        {
-            return CloneEmpty<TResult>(dimensions);
-        }
-
-        /// <summary>
-        /// Creates a new Tensor of a different type with the specified dimensions and the same layout as this tensor with elements initialized to their default value.
-        /// </summary>
-        /// <typeparam name="TResult">Type contained within the new Tensor.  Typically a value type such as int, double, float, etc.</typeparam>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the DenseTensor to create.</param>
-        /// <returns>A new Tensor with the same layout as this tensor of specified <paramref name="dimensions"/> with elements of <typeparamref name="TResult"/> type initialized to their default value.</returns>
-        public abstract Tensor<TResult> CloneEmpty<TResult>(ReadOnlySpan<int> dimensions);
-
-        /// <summary>
-        /// Gets the n-1 dimension diagonal from the n dimension tensor.
-        /// </summary>
-        /// <returns>An n-1 dimension tensor with the values from the main diagonal of this tensor.</returns>
-        public Tensor<T> GetDiagonal()
-        {
-            return GetDiagonal(0);
-        }
-
-        /// <summary>
-        /// Gets the n-1 dimension diagonal from the n dimension tensor at the specified offset from center.
-        /// </summary>
-        /// <param name="offset">Offset of diagonal to set in returned tensor.  0 for the main diagonal, less than zero for diagonals below, greater than zero from diagonals above.</param>
-        /// <returns>An n-1 dimension tensor with the values from the specified diagonal of this tensor.</returns>
-        public Tensor<T> GetDiagonal(int offset)
-        {
-            // Get diagonal of first two dimensions for all remaining dimensions
-
-            // diagnonal is as follows:
-            // { 1, 2, 4 }
-            // { 8, 3, 9 }
-            // { 0, 7, 5 }
-            // The diagonal at offset 0 is { 1, 3, 5 }
-            // The diagonal at offset 1 is { 2, 9 }
-            // The diagonal at offset -1 is { 8, 7 }
-
-            if (Rank < 2)
-            {
-                throw new InvalidOperationException(SR.Format(SR.CannotComputeDiagonal, nameof(Tensor<T>)));
-            }
-
-            // TODO: allow specification of axis1 and axis2?
-            var axisLength0 = dimensions[0];
-            var axisLength1 = dimensions[1];
-
-            // the diagonal will be the length of the smaller axis
-            // if offset it positive, the length will shift along the second axis
-            // if the offset is negative, the length will shift along the first axis
-            // In that way the length of the diagonal will be
-            //   Min(offset < 0 ? axisLength0 + offset : axisLength0, offset > 0 ? axisLength1 - offset : axisLength1)
-            // To illustrate, consider the following
-            // { 1, 2, 4, 3, 7 }
-            // { 8, 3, 9, 2, 6 }
-            // { 0, 7, 5, 2, 9 }
-            // The diagonal at offset 0 is { 1, 3, 5 }, Min(3, 5) = 3
-            // The diagonal at offset 1 is { 2, 9, 2 }, Min(3, 5 - 1) = 3
-            // The diagonal at offset 3 is { 3, 6 }, Min(3, 5 - 3) = 2
-            // The diagonal at offset -1 is { 8, 7 }, Min(3 - 1, 5) = 2
-            var offsetAxisLength0 = offset < 0 ? axisLength0 + offset : axisLength0;
-            var offsetAxisLength1 = offset > 0 ? axisLength1 - offset : axisLength1;
-
-            var diagonalLength = Math.Min(offsetAxisLength0, offsetAxisLength1);
-
-            if (diagonalLength <= 0)
-            {
-                throw new ArgumentException(SR.Format(SR.CannotComputeDiagonalWithOffset, offset), nameof(offset));
-            }
-
-            var newTensorRank = Rank - 1;
-            var newTensorDimensions = newTensorRank < ArrayUtilities.StackallocMax ? stackalloc int[newTensorRank] : new int[newTensorRank];
-            newTensorDimensions[0] = diagonalLength;
-
-            for (int i = 2; i < dimensions.Length; i++)
-            {
-                newTensorDimensions[i - 1] = dimensions[i];
-            }
-
-            var diagonalTensor = CloneEmpty(newTensorDimensions);
-            var sizePerDiagonal = diagonalTensor.Length / diagonalTensor.Dimensions[0];
-
-            var diagProjectionStride = diagonalTensor.IsReversedStride && diagonalTensor.Rank > 1 ? diagonalTensor.strides[1] : 1;
-            var sourceProjectionStride = IsReversedStride && Rank > 2 ? strides[2] : 1;
-
-            for (int diagIndex = 0; diagIndex < diagonalLength; diagIndex++)
-            {
-                var sourceIndex0 = offset < 0 ? diagIndex - offset : diagIndex;
-                var sourceIndex1 = offset > 0 ? diagIndex + offset : diagIndex;
-
-                var sourceBase = sourceIndex0 * strides[0] + sourceIndex1 * strides[1];
-                var diagBase = diagIndex * diagonalTensor.strides[0];
-
-                for (int diagProjectionIndex = 0; diagProjectionIndex < sizePerDiagonal; diagProjectionIndex++)
-                {
-                    diagonalTensor.SetValue(diagBase + diagProjectionIndex * diagProjectionStride,
-                        GetValue(sourceBase + diagProjectionIndex * sourceProjectionStride));
-                }
-            }
-
-            return diagonalTensor;
-        }
-
-        /// <summary>
-        /// Gets a tensor representing the elements below and including the diagonal, with the rest of the elements zero-ed.
-        /// </summary>
-        /// <returns>A tensor with the values from this tensor at and below the main diagonal and zeros elsewhere.</returns>
-        public Tensor<T> GetTriangle()
-        {
-            return GetTriangle(0, upper: false);
-        }
-
-        /// <summary>
-        /// Gets a tensor representing the elements below and including the specified diagonal, with the rest of the elements zero-ed.
-        /// </summary>
-        /// <param name="offset">Offset of diagonal to set in returned tensor.  0 for the main diagonal, less than zero for diagonals below, greater than zero from diagonals above.</param>
-        /// <returns>A tensor with the values from this tensor at and below the specified diagonal and zeros elsewhere.</returns>
-        public Tensor<T> GetTriangle(int offset)
-        {
-            return GetTriangle(offset, upper: false);
-        }
-
-        /// <summary>
-        /// Gets a tensor representing the elements above and including the diagonal, with the rest of the elements zero-ed.
-        /// </summary>
-        /// <returns>A tensor with the values from this tensor at and above the main diagonal and zeros elsewhere.</returns>
-        public Tensor<T> GetUpperTriangle()
-        {
-            return GetTriangle(0, upper: true);
-        }
-
-        /// <summary>
-        /// Gets a tensor representing the elements above and including the specified diagonal, with the rest of the elements zero-ed.
-        /// </summary>
-        /// <param name="offset">Offset of diagonal to set in returned tensor.  0 for the main diagonal, less than zero for diagonals below, greater than zero from diagonals above.</param>
-        /// <returns>A tensor with the values from this tensor at and above the specified diagonal and zeros elsewhere.</returns>
-        public Tensor<T> GetUpperTriangle(int offset)
-        {
-            return GetTriangle(offset, upper: true);
-        }
-
-        private Tensor<T> GetTriangle(int offset, bool upper)
-        {
-            if (Rank < 2)
-            {
-                throw new InvalidOperationException(SR.Format(SR.CannotComputeTriangle, nameof(Tensor<T>)));
-            }
-
-            // Similar to get diagonal except it gets every element below and including the diagonal.
-
-            // TODO: allow specification of axis1 and axis2?
-            var axisLength0 = dimensions[0];
-            var axisLength1 = dimensions[1];
-            var diagonalLength = Math.Max(axisLength0, axisLength1);
-
-            var result = CloneEmpty();
-
-            var projectionSize = Length / (axisLength0 * axisLength1);
-            var projectionStride = IsReversedStride && Rank > 2 ? strides[2] : 1;
-
-            for (int diagIndex = 0; diagIndex < diagonalLength; diagIndex++)
-            {
-                // starting point for the tri
-                var triIndex0 = offset > 0 ? diagIndex - offset : diagIndex;
-                var triIndex1 = offset > 0 ? diagIndex : diagIndex + offset;
-
-                // for lower triangle, iterate index0 keeping same index1
-                // for upper triangle, iterate index1 keeping same index0
-
-                if (triIndex0 < 0)
-                {
-                    if (upper)
-                    {
-                        // out of bounds, ignore this diagIndex.
-                        continue;
-                    }
-                    else
-                    {
-                        // set index to 0 so that we can iterate on the remaining index0 values.
-                        triIndex0 = 0;
-                    }
-                }
-
-                if (triIndex1 < 0)
-                {
-                    if (upper)
-                    {
-                        // set index to 0 so that we can iterate on the remaining index1 values.
-                        triIndex1 = 0;
-                    }
-                    else
-                    {
-                        // out of bounds, ignore this diagIndex.
-                        continue;
-                    }
-                }
-
-                while ((triIndex1 < axisLength1) && (triIndex0 < axisLength0))
-                {
-                    var baseIndex = triIndex0 * strides[0] + triIndex1 * result.strides[1];
-
-                    for (int projectionIndex = 0; projectionIndex < projectionSize; projectionIndex++)
-                    {
-                        var index = baseIndex + projectionIndex * projectionStride;
-
-                        result.SetValue(index, GetValue(index));
-                    }
-
-                    if (upper)
-                    {
-                        triIndex1++;
-                    }
-                    else
-                    {
-                        triIndex0++;
-                    }
-                }
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Reshapes the current tensor to new dimensions, using the same backing storage if possible.
-        /// </summary>
-        /// <param name="dimensions">An span of integers that represent the size of each dimension of the Tensor to create.</param>
-        /// <returns>A new tensor that reinterprets this tensor with different dimensions.</returns>
-        public abstract Tensor<T> Reshape(ReadOnlySpan<int> dimensions);
-
-        /// <summary>
-        /// Obtains the value at the specified indices
-        /// </summary>
-        /// <param name="indices">A one-dimensional array of integers that represent the indices specifying the position of the element to get.</param>
-        /// <returns>The value at the specified position in this Tensor.</returns>
-        public virtual T this[params int[] indices]
-        {
-            get
-            {
-                if (indices is null)
-                {
-                    throw new ArgumentNullException(nameof(indices));
-                }
-
-                var span = new ReadOnlySpan<int>(indices);
-                return this[span];
-            }
-
-            set
-            {
-                if (indices is null)
-                {
-                    throw new ArgumentNullException(nameof(indices));
-                }
-
-                var span = new ReadOnlySpan<int>(indices);
-                this[span] = value;
-            }
-        }
-
-        /// <summary>
-        /// Obtains the value at the specified indices
-        /// </summary>
-        /// <param name="indices">A span integers that represent the indices specifying the position of the element to get.</param>
-        /// <returns>The value at the specified position in this Tensor.</returns>
-        public virtual T this[ReadOnlySpan<int> indices]
-        {
-            get
-            {
-                return GetValue(ArrayUtilities.GetIndex(strides, indices));
-            }
-
-            set
-            {
-                SetValue(ArrayUtilities.GetIndex(strides, indices), value);
-            }
-        }
-
-        /// <summary>
-        /// Gets the value at the specified index, where index is a linearized version of n-dimension indices using strides.
-        /// </summary>
-        /// <param name="index">An integer index computed as a dot-product of indices.</param>
-        /// <returns>The value at the specified position in this Tensor.</returns>
-        public abstract T GetValue(int index);
-
-        /// <summary>
-        /// Sets the value at the specified index, where index is a linearized version of n-dimension indices using strides.
-        /// </summary>
-        /// <param name="index">An integer index computed as a dot-product of indices.</param>
-        /// <param name="value">The new value to set at the specified position in this Tensor.</param>
-        public abstract void SetValue(int index, T value);
-
-        /// <summary>
-        /// The type that implements enumerators for <see cref="Tensor{T}"/> instances.
-        /// </summary>
-        public struct Enumerator : IEnumerator<T>
-        {
-            private readonly Tensor<T> _tensor;
-            private int _index;
-
-            internal Enumerator(Tensor<T> tensor)
-            {
-                Debug.Assert(tensor != null);
-
-                _tensor = tensor;
-                _index = 0;
-                Current = default!;
-            }
-
-            public T Current { get; private set; }
-
-            object? IEnumerator.Current => Current;
-
-            public bool MoveNext()
-            {
-                if (_index < _tensor.Length)
-                {
-                    Current = _tensor.GetValue(_index);
-                    ++_index;
-                    return true;
-                }
-                else
-                {
-                    Current = default!;
-                    return false;
-                }
-            }
-
-            /// <summary>
-            /// Resets the enumerator to the beginning.
-            /// </summary>
-            public void Reset()
-            {
-                _index = 0;
-                Current = default!;
-            }
-
-            /// <summary>
-            /// Disposes the enumerator.
-            /// </summary>
-            public void Dispose() { }
-        }
-
-        /// <summary>
-        /// Gets an enumerator that enumerates the elements of the <see cref="Tensor{T}"/>.
-        /// </summary>
-        /// <returns>An enumerator for the current <see cref="Tensor{T}"/>.</returns>
-        public Enumerator GetEnumerator() => new Enumerator(this);
-
-        #region statics
-        /// <summary>
-        /// Performs a value comparison of the content and shape of two tensors.  Two tensors are equal if they have the same shape and same value at every set of indices.  If not equal a tensor is greater or less than another tensor based on the first non-equal element when enumerating in linear order.
-        /// </summary>
-        /// <param name="left"></param>
-        /// <param name="right"></param>
-        /// <returns></returns>
-        public static int Compare(Tensor<T> left, Tensor<T> right)
-        {
-            return StructuralComparisons.StructuralComparer.Compare(left, right);
-        }
-
-        /// <summary>
-        /// Performs a value equality comparison of the content of two tensors. Two tensors are equal if they have the same shape and same value at every set of indices.
-        /// </summary>
-        /// <param name="left"></param>
-        /// <param name="right"></param>
-        /// <returns></returns>
-        public static bool Equals(Tensor<T> left, Tensor<T> right)
-        {
-            return StructuralComparisons.StructuralEqualityComparer.Equals(left, right);
-        }
-        #endregion
-
-        #region IEnumerable members
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-        #endregion
-
-        #region ICollection members
-        int ICollection.Count => (int)Length;
-
-        bool ICollection.IsSynchronized => false;
-
-        object ICollection.SyncRoot => this; // backingArray.this?
-
-        void ICollection.CopyTo(Array array, int index)
-        {
-            if (array is T[] destinationArray)
-            {
-                CopyTo(destinationArray, index);
-            }
-            else
-            {
-                if (array == null)
-                {
-                    throw new ArgumentNullException(nameof(array));
-                }
-                if (array.Rank != 1)
-                {
-                    throw new ArgumentException(SR.OnlySingleDimensionalArraysSupported, nameof(array));
-                }
-                if (array.Length < index + Length)
-                {
-                    throw new ArgumentException(SR.NumberGreaterThenAvailableSpace, nameof(array));
-                }
-
-                for (int i = 0; i < length; i++)
-                {
-                    array.SetValue(GetValue(i), index + i);
-                }
-            }
-        }
-        #endregion
-
-        #region IList members
-        object? IList.this[int index]
-        {
-            get
-            {
-                return GetValue(index);
-            }
-            set
-            {
-                try
-                {
-                    SetValue(index, (T)value!);
-                }
-                catch (InvalidCastException)
-                {
-                    throw new ArgumentException(SR.Format(SR.ValueIsNotOfType, value, typeof(T)));
-                }
-            }
-        }
-
-        public bool IsFixedSize => true;
-
-        public bool IsReadOnly => false;
-
-        int IList.Add(object? value)
-        {
-            throw new InvalidOperationException();
-        }
-
-        void IList.Clear()
-        {
-            Fill(default!);
-        }
-
-        bool IList.Contains(object? value)
-        {
-            if (IsCompatibleObject(value!))
-            {
-                return Contains((T)value!);
-            }
-            return false;
-        }
-
-        int IList.IndexOf(object? value)
-        {
-            if (IsCompatibleObject(value!))
-            {
-                return IndexOf((T)value!);
-            }
-            return -1;
-        }
-
-        void IList.Insert(int index, object? value)
-        {
-            throw new InvalidOperationException();
-        }
-
-        void IList.Remove(object? value)
-        {
-            throw new InvalidOperationException();
-        }
-
-        void IList.RemoveAt(int index)
-        {
-            throw new InvalidOperationException();
-        }
-        #endregion
-
-        #region IEnumerable<T> members
-        IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
-        #endregion
-
-        #region ICollection<T> members
-        int ICollection<T>.Count => (int)Length;
-
-        void ICollection<T>.Add(T item)
-        {
-            throw new InvalidOperationException();
-        }
-
-        void ICollection<T>.Clear()
-        {
-            Fill(default!);
-        }
-
-        bool ICollection<T>.Contains(T item)
-        {
-            return Contains(item);
-        }
-
-        /// <summary>
-        /// Determines whether an element is in the Tensor&lt;T&gt;.
-        /// </summary>
-        /// <param name="item">
-        /// The object to locate in the Tensor&lt;T&gt;. The value can be null for reference types.
-        /// </param>
-        /// <returns>
-        /// true if item is found in the Tensor&lt;T&gt;; otherwise, false.
-        /// </returns>
-        protected virtual bool Contains(T item)
-        {
-            return Length != 0 && IndexOf(item) != -1;
-        }
-
-        void ICollection<T>.CopyTo(T[] array, int arrayIndex)
-        {
-            CopyTo(array, arrayIndex);
-        }
-
-        /// <summary>
-        /// Copies the elements of the Tensor&lt;T&gt; to an Array, starting at a particular Array index.
-        /// </summary>
-        /// <param name="array">
-        /// The one-dimensional Array that is the destination of the elements copied from Tensor&lt;T&gt;. The Array must have zero-based indexing.
-        /// </param>
-        /// <param name="arrayIndex">
-        /// The zero-based index in array at which copying begins.
-        /// </param>
-        protected virtual void CopyTo(T[] array, int arrayIndex)
-        {
-            if (array is null)
-            {
-                throw new ArgumentNullException(nameof(array));
-            }
-
-            if (array.Length < arrayIndex + Length)
-            {
-                throw new ArgumentException(SR.NumberGreaterThenAvailableSpace, nameof(array));
-            }
-
-            for (int i = 0; i < length; i++)
-            {
-                array[arrayIndex + i] = GetValue(i);
-            }
-        }
-
-        bool ICollection<T>.Remove(T item)
-        {
-            throw new InvalidOperationException();
-        }
-        #endregion
-
-        #region IReadOnlyCollection<T> members
-
-        int IReadOnlyCollection<T>.Count => (int)Length;
-
-        #endregion
-
-        #region IList<T> members
-        T IList<T>.this[int index]
-        {
-            get { return GetValue(index); }
-            set { SetValue(index, value); }
-        }
-
-        int IList<T>.IndexOf(T item)
-        {
-            return IndexOf(item);
-        }
-
-        /// <summary>
-        /// Determines the index of a specific item in the Tensor&lt;T&gt;.
-        /// </summary>
-        /// <param name="item">The object to locate in the Tensor&lt;T&gt;.</param>
-        /// <returns>The index of item if found in the tensor; otherwise, -1.</returns>
-        protected virtual int IndexOf(T item)
-        {
-            for (int i = 0; i < Length; i++)
-            {
-                if (GetValue(i)!.Equals(item))
-                {
-                    return i;
-                }
-            }
-
-            return -1;
-        }
-
-        void IList<T>.Insert(int index, T item)
-        {
-            throw new InvalidOperationException();
-        }
-
-        void IList<T>.RemoveAt(int index)
-        {
-            throw new InvalidOperationException();
-        }
-        #endregion
-
-        #region IReadOnlyList<T> members
-
-        T IReadOnlyList<T>.this[int index] => GetValue(index);
-
-        #endregion
-
-        #region IStructuralComparable members
-        int IStructuralComparable.CompareTo(object? other, IComparer comparer)
-        {
-            if (other == null)
-            {
-                return 1;
-            }
-
-            if (other is Tensor<T>)
-            {
-                return CompareTo((Tensor<T>)other, comparer);
-            }
-
-            var otherArray = other as Array;
-
-            if (otherArray != null)
-            {
-                return CompareTo(otherArray, comparer);
-            }
-
-            throw new ArgumentException(SR.Format(SR.CannotCompare, nameof(Tensor<T>), other.GetType()), nameof(other));
-        }
-
-        private int CompareTo(Tensor<T> other, IComparer comparer)
-        {
-            if (Rank != other.Rank)
-            {
-                throw new ArgumentException(SR.Format(SR.CannotCompareWithRank, nameof(Tensor<T>), Rank, nameof(other), other.Rank), nameof(other));
-            }
-
-            for (int i = 0; i < dimensions.Length; i++)
-            {
-                if (dimensions[i] != other.dimensions[i])
-                {
-                    throw new ArgumentException(SR.Format(SR.CannotCompareWithDifferentDimension, nameof(Tensor<T>), i, dimensions[i], other.dimensions[i]), nameof(other));
-                }
-            }
-
-            int result = 0;
-
-            if (IsReversedStride == other.IsReversedStride)
-            {
-                for (int i = 0; i < Length; i++)
-                {
-                    result = comparer.Compare(GetValue(i), other.GetValue(i));
-                    if (result != 0)
-                    {
-                        break;
-                    }
-                }
-            }
-            else
-            {
-                var indices = Rank < ArrayUtilities.StackallocMax ? stackalloc int[Rank] : new int[Rank];
-                for (int i = 0; i < Length; i++)
-                {
-                    ArrayUtilities.GetIndices(strides, IsReversedStride, i, indices);
-                    result = comparer.Compare(this[indices], other[indices]);
-                    if (result != 0)
-                    {
-                        break;
-                    }
-                }
-            }
-
-            return result;
-        }
-
-        private int CompareTo(Array other, IComparer comparer)
-        {
-            if (Rank != other.Rank)
-            {
-                throw new ArgumentException(SR.Format(SR.CannotCompareWithRank, nameof(Tensor<T>), Rank, nameof(Array), other.Rank), nameof(other));
-            }
-
-            for (int i = 0; i < dimensions.Length; i++)
-            {
-                var otherDimension = other.GetLength(i);
-                if (dimensions[i] != otherDimension)
-                {
-                    throw new ArgumentException(SR.Format(SR.CannotCompareToWithDifferentDimension, nameof(Tensor<T>), nameof(Array), i, dimensions[i], otherDimension), nameof(other));
-                }
-            }
-
-            int result = 0;
-            var indices = new int[Rank];
-            for (int i = 0; i < Length; i++)
-            {
-                ArrayUtilities.GetIndices(strides, IsReversedStride, i, indices);
-
-                result = comparer.Compare(GetValue(i), other.GetValue(indices));
-
-                if (result != 0)
-                {
-                    break;
-                }
-            }
-
-            return result;
-        }
-        #endregion
-
-        #region IStructuralEquatable members
-        bool IStructuralEquatable.Equals(object? other, IEqualityComparer comparer)
-        {
-            if (other == null)
-            {
-                return false;
-            }
-
-            if (other is Tensor<T>)
-            {
-                return Equals((Tensor<T>)other, comparer);
-            }
-
-            var otherArray = other as Array;
-
-            if (otherArray != null)
-            {
-                return Equals(otherArray, comparer);
-            }
-
-            throw new ArgumentException(SR.Format(SR.CannotCompare, nameof(Tensor<T>), other.GetType()), nameof(other));
-        }
-
-        private bool Equals(Tensor<T> other, IEqualityComparer comparer)
-        {
-            if (Rank != other.Rank)
-            {
-                throw new ArgumentException(SR.Format(SR.CannotCompareWithRank, nameof(Tensor<T>), Rank, nameof(other), other.Rank), nameof(other));
-            }
-
-            for (int i = 0; i < dimensions.Length; i++)
-            {
-                if (dimensions[i] != other.dimensions[i])
-                {
-                    throw new ArgumentException(SR.Format(SR.CannotCompareWithDifferentDimension, nameof(Tensor<T>), i, dimensions[i], other.dimensions[i]), nameof(other));
-                }
-            }
-
-            if (IsReversedStride == other.IsReversedStride)
-            {
-                for (int i = 0; i < Length; i++)
-                {
-                    if (!comparer.Equals(GetValue(i), other.GetValue(i)))
-                    {
-                        return false;
-                    }
-                }
-            }
-            else
-            {
-                var indices = Rank < ArrayUtilities.StackallocMax ? stackalloc int[Rank] : new int[Rank];
-                for (int i = 0; i < Length; i++)
-                {
-                    ArrayUtilities.GetIndices(strides, IsReversedStride, i, indices);
-
-                    if (!comparer.Equals(this[indices], other[indices]))
-                    {
-                        return false;
-                    }
-                }
-            }
-
-            return true;
-        }
-
-        private bool Equals(Array other, IEqualityComparer comparer)
-        {
-            if (Rank != other.Rank)
-            {
-                throw new ArgumentException(SR.Format(SR.CannotCompareWithRank, nameof(Tensor<T>), Rank, nameof(Array), other.Rank), nameof(other));
-            }
-
-            for (int i = 0; i < dimensions.Length; i++)
-            {
-                var otherDimension = other.GetLength(i);
-                if (dimensions[i] != otherDimension)
-                {
-                    throw new ArgumentException(SR.Format(SR.CannotCompareToWithDifferentDimension, nameof(Tensor<T>), nameof(Array), i, dimensions[i], otherDimension), nameof(other));
-                }
-            }
-
-            var indices = new int[Rank];
-            for (int i = 0; i < Length; i++)
-            {
-                ArrayUtilities.GetIndices(strides, IsReversedStride, i, indices);
-
-                if (!comparer.Equals(GetValue(i), other.GetValue(indices)))
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-        int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
-        {
-            int hashCode = 0;
-            // this ignores shape, which is fine  it just means we'll have hash collisions for things
-            // with the same content and different shape.
-            for (int i = 0; i < Length; i++)
-            {
-                hashCode ^= comparer.GetHashCode(GetValue(i)!);
-            }
-
-            return hashCode;
-        }
-        #endregion
-
-        #region Translations
-
-        /// <summary>
-        /// Creates a copy of this tensor as a DenseTensor&lt;T&gt;.  If this tensor is already a DenseTensor&lt;T&gt; calling this method is equivalent to calling Clone().
-        /// </summary>
-        /// <returns></returns>
-        public virtual DenseTensor<T> ToDenseTensor()
-        {
-            var denseTensor = new DenseTensor<T>(Dimensions, IsReversedStride);
-            for (int i = 0; i < Length; i++)
-            {
-                denseTensor.SetValue(i, GetValue(i));
-            }
-            return denseTensor;
-        }
-
-
-        /// <summary>
-        /// Creates a copy of this tensor as a SparseTensor&lt;T&gt;.  If this tensor is already a SparseTensor&lt;T&gt; calling this method is equivalent to calling Clone().
-        /// </summary>
-        /// <returns></returns>
-        public virtual SparseTensor<T> ToSparseTensor()
-        {
-            var sparseTensor = new SparseTensor<T>(Dimensions, IsReversedStride);
-            for (int i = 0; i < Length; i++)
-            {
-                sparseTensor.SetValue(i, GetValue(i));
-            }
-            return sparseTensor;
-        }
-
-        /// <summary>
-        /// Creates a copy of this tensor as a CompressedSparseTensor&lt;T&gt;.  If this tensor is already a CompressedSparseTensor&lt;T&gt; calling this method is equivalent to calling Clone().
-        /// </summary>
-        /// <returns></returns>
-        public virtual CompressedSparseTensor<T> ToCompressedSparseTensor()
-        {
-            var compressedSparseTensor = new CompressedSparseTensor<T>(Dimensions, IsReversedStride);
-            for (int i = 0; i < Length; i++)
-            {
-                compressedSparseTensor.SetValue(i, GetValue(i));
-            }
-            return compressedSparseTensor;
-        }
-
-        #endregion
-
-        public string GetArrayString(bool includeWhitespace = true)
-        {
-            var builder = new StringBuilder();
-
-            var strides = ArrayUtilities.GetStrides(dimensions);
-            var indices = new int[Rank];
-            var innerDimension = Rank - 1;
-            var innerLength = dimensions[innerDimension];
-
-            int indent = 0;
-            for (int outerIndex = 0; outerIndex < Length; outerIndex += innerLength)
-            {
-                ArrayUtilities.GetIndices(strides, false, outerIndex, indices);
-
-                while ((indent < innerDimension) && (indices[indent] == 0))
-                {
-                    // start up
-                    if (includeWhitespace)
-                    {
-                        Indent(builder, indent);
-                    }
-                    indent++;
-                    builder.Append('{');
-                    if (includeWhitespace)
-                    {
-                        builder.AppendLine();
-                    }
-                }
-
-                for (int innerIndex = 0; innerIndex < innerLength; innerIndex++)
-                {
-                    indices[innerDimension] = innerIndex;
-
-                    if ((innerIndex == 0))
-                    {
-                        if (includeWhitespace)
-                        {
-                            Indent(builder, indent);
-                        }
-                        builder.Append('{');
-                    }
-                    else
-                    {
-                        builder.Append(',');
-                    }
-                    builder.Append(this[indices]);
-                }
-                builder.Append('}');
-
-                for (int i = Rank - 2; i >= 0; i--)
-                {
-                    var lastIndex = dimensions[i] - 1;
-                    if (indices[i] == lastIndex)
-                    {
-                        // close out
-                        --indent;
-                        if (includeWhitespace)
-                        {
-                            builder.AppendLine();
-                            Indent(builder, indent);
-                        }
-                        builder.Append('}');
-                    }
-                    else
-                    {
-                        builder.Append(',');
-                        if (includeWhitespace)
-                        {
-                            builder.AppendLine();
-                        }
-                        break;
-                    }
-                }
-            }
-
-            return builder.ToString();
-        }
-
-        private static void Indent(StringBuilder builder, int tabs, int spacesPerTab = 4)
-        {
-            for (int tab = 0; tab < tabs; tab++)
-            {
-                for (int space = 0; space < spacesPerTab; space++)
-                {
-                    builder.Append(' ');
-                }
-            }
-        }
-
-        private static bool IsCompatibleObject(object value)
-        {
-            // Non-null values are fine.  Only accept nulls if T is a class or Nullable<T>.
-            // Note that default(T) is not equal to null for value types except when T is Nullable<T>.
-            return ((value is T) || (value == null && default(T) == null));
-        }
-    }
-}
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.cs
new file mode 100644
index 00000000000000..10f29183ea2869
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.cs
@@ -0,0 +1,467 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Numerics.Tensors
+{
+    /// <summary>Performs primitive tensor operations over spans of memory.</summary>
+    public static class TensorPrimitives
+    {
+        /// <summary>Computes the element-wise result of: <c><paramref name="x" /> + <paramref name="y" /></c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <paramref name="x" />[i] + <paramref name="y" />[i]</c>.</remarks>
+        public static void Add(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            if (x.Length != y.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(y));
+            }
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = x[i] + y[i];
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c><paramref name="x" /> + <paramref name="y" /></c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <paramref name="x" />[i] + <paramref name="y" /></c>.</remarks>
+        public static void Add(ReadOnlySpan<float> x, float y, Span<float> destination)
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = x[i] + y;
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c><paramref name="x" /> - <paramref name="y" /></c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <paramref name="x" />[i] - <paramref name="y" />[i]</c>.</remarks>
+        public static void Subtract(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            if (x.Length != y.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(y));
+            }
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = x[i] - y[i];
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c><paramref name="x" /> - <paramref name="y" /></c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <paramref name="x" />[i] - <paramref name="y" /></c>.</remarks>
+        public static void Subtract(ReadOnlySpan<float> x, float y, Span<float> destination)
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = x[i] - y;
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c><paramref name="x" /> * <paramref name="y" /></c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <paramref name="x" />[i] * <paramref name="y" /></c>.</remarks>
+        public static void Multiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            if (x.Length != y.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(y));
+            }
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = x[i] * y[i];
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c><paramref name="x" /> * <paramref name="y" /></c>.</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>
+        /// <remarks>
+        ///     <para>This method effectively does <c><paramref name="destination" />[i] = <paramref name="x" />[i] * <paramref name="y" /></c>.</para>
+        ///     <para>This method corresponds to the <c>scal</c> method defined by <c>BLAS1</c>.</para>
+        /// </remarks>
+        public static void Multiply(ReadOnlySpan<float> x, float y, Span<float> destination)
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = x[i] * y;
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c><paramref name="x" /> / <paramref name="y" /></c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <paramref name="x" />[i] / <paramref name="y" /></c>.</remarks>
+        public static void Divide(ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination)
+        {
+            if (x.Length != y.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(y));
+            }
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = x[i] / y[i];
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c><paramref name="x" /> / <paramref name="y" /></c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <paramref name="x" />[i] / <paramref name="y" /></c>.</remarks>
+        public static void Divide(ReadOnlySpan<float> x, float y, Span<float> destination)
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = x[i] / y;
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>-<paramref name="x" /></c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = -<paramref name="x" />[i]</c>.</remarks>
+        public static void Negate(ReadOnlySpan<float> x, Span<float> destination)
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = -x[i];
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c>.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="multiplier">The third tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <exception cref="ArgumentException">Length of '<paramref name="x" />' must be same as length of '<paramref name="y" />'.</exception>
+        /// <exception cref="ArgumentException">Length of '<paramref name="x" />' must be same as length of '<paramref name="multiplier" />'.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = (<paramref name="x" />[i] + <paramref name="y" />[i]) * <paramref name="multiplier" />[i]</c>.</remarks>
+        public static void AddMultiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, ReadOnlySpan<float> multiplier, Span<float> destination)
+        {
+            if (x.Length != y.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(y));
+            }
+
+            if (x.Length != multiplier.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(multiplier));
+            }
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = (x[i] + y[i]) * multiplier[i];
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = (<paramref name="x" />[i] + <paramref name="y" />[i]) * <paramref name="multiplier" /></c>.</remarks>
+        public static void AddMultiply(ReadOnlySpan<float> x, ReadOnlySpan<float> y, float multiplier, Span<float> destination)
+        {
+            if (x.Length != y.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(y));
+            }
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = (x[i] + y[i]) * multiplier;
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>(<paramref name="x" /> + <paramref name="y" />) * <paramref name="multiplier" /></c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = (<paramref name="x" />[i] + <paramref name="y" />) * <paramref name="multiplier" />[i]</c>.</remarks>
+        public static void AddMultiply(ReadOnlySpan<float> x, float y, ReadOnlySpan<float> multiplier, Span<float> destination)
+        {
+            if (x.Length != multiplier.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(multiplier));
+            }
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = (x[i] + y) * multiplier[i];
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>(<paramref name="x" /> * <paramref name="y" />) + <paramref name="addend" /></c>.</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" />'.</exception>
+        /// <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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = (<paramref name="x" />[i] * <paramref name="y" />[i]) + <paramref name="addend" />[i]</c>.</remarks>
+        public static void MultiplyAdd(ReadOnlySpan<float> x, ReadOnlySpan<float> y, ReadOnlySpan<float> addend, Span<float> destination)
+        {
+            if (x.Length != y.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(y));
+            }
+
+            if (x.Length != addend.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(addend));
+            }
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = (x[i] * y[i]) + addend[i];
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>(<paramref name="x" /> * <paramref name="y" />) + <paramref name="addend" /></c>.</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" />'.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <remarks>
+        ///     <para>This method effectively does <c><paramref name="destination" />[i] = (<paramref name="x" />[i] * <paramref name="y" />[i]) + <paramref name="addend" /></c>.</para>
+        ///     <para>This method corresponds to the <c>axpy</c> method defined by <c>BLAS1</c>.</para>
+        /// </remarks>
+        public static void MultiplyAdd(ReadOnlySpan<float> x, ReadOnlySpan<float> y, float addend, Span<float> destination)
+        {
+            if (x.Length != y.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(y));
+            }
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = (x[i] * y[i]) + addend;
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>(<paramref name="x" /> * <paramref name="y" />) + <paramref name="addend" /></c>.</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="addend" />'.</exception>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = (<paramref name="x" />[i] * <paramref name="y" />) + <paramref name="addend" />[i]</c>.</remarks>
+        public static void MultiplyAdd(ReadOnlySpan<float> x, float y, ReadOnlySpan<float> addend, Span<float> destination)
+        {
+            if (x.Length != addend.Length)
+            {
+                ThrowHelper.ThrowArgument_SpansMustHaveSameLength(nameof(x), nameof(addend));
+            }
+
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = (x[i] * y) + addend[i];
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>pow(e, <paramref name="x" />)</c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <see cref="MathF" />.Exp(<paramref name="x" />[i])</c>.</remarks>
+        public static void Exp(ReadOnlySpan<float> x, Span<float> destination)
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = MathF.Exp(x[i]);
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>ln(<paramref name="x" />)</c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <see cref="MathF" />.Log(<paramref name="x" />[i])</c>.</remarks>
+        public static void Log(ReadOnlySpan<float> x, Span<float> destination)
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = MathF.Log(x[i]);
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>cosh(<paramref name="x" />)</c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <see cref="MathF" />.Cosh(<paramref name="x" />[i])</c>.</remarks>
+        public static void Cosh(ReadOnlySpan<float> x, Span<float> destination)
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = MathF.Cosh(x[i]);
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>sinh(<paramref name="x" />)</c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <see cref="MathF" />.Sinh(<paramref name="x" />[i])</c>.</remarks>
+        public static void Sinh(ReadOnlySpan<float> x, Span<float> destination)
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = MathF.Sinh(x[i]);
+            }
+        }
+
+        /// <summary>Computes the element-wise result of: <c>tanh(<paramref name="x" />)</c>.</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>
+        /// <remarks>This method effectively does <c><paramref name="destination" />[i] = <see cref="MathF" />.Tanh(<paramref name="x" />[i])</c>.</remarks>
+        public static void Tanh(ReadOnlySpan<float> x, Span<float> destination)
+        {
+            if (x.Length > destination.Length)
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+
+            for (int i = 0; i < x.Length; i++)
+            {
+                destination[i] = MathF.Tanh(x[i]);
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs b/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs
new file mode 100644
index 00000000000000..5ae36ffbed7682
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs
@@ -0,0 +1,32 @@
+// 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;
+
+namespace System
+{
+    //
+    // This pattern of easily inlinable "void Throw" routines that stack on top of NoInlining factory methods
+    // is a compromise between older JITs and newer JITs (RyuJIT in .NET Core 1.1.0+ and .NET Framework in 4.6.3+).
+    // This package is explicitly targeted at older JITs as newer runtimes expect to implement Span intrinsically for
+    // best performance.
+    //
+    // The aim of this pattern is three-fold
+    // 1. Extracting the throw makes the method preforming the throw in a conditional branch smaller and more inlinable
+    // 2. Extracting the throw from generic method to non-generic method reduces the repeated codegen size for value types
+    // 3a. Newer JITs will not inline the methods that only throw and also recognise them, move the call to cold section
+    //     and not add stack prep and unwind before calling https://github.com/dotnet/coreclr/pull/6103
+    // 3b. Older JITs will inline the throw itself and move to cold section; but not inline the non-inlinable exception
+    //     factory methods - still maintaining advantages 1 & 2
+    //
+
+    internal static class ThrowHelper
+    {
+        [DoesNotReturn]
+        public static void ThrowArgument_DestinationTooShort() => throw new ArgumentException(SR.Argument_DestinationTooShort);
+
+        [DoesNotReturn]
+        public static void ThrowArgument_SpansMustHaveSameLength(string paramName1, string paramName2)
+            => throw new ArgumentException(SR.Format(SR.Argument_SpansMustHaveSameLength, paramName1, paramName2), paramName1);
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/tests/NativeMemory.cs b/src/libraries/System.Numerics.Tensors/tests/NativeMemory.cs
deleted file mode 100644
index b5c9ef8c2c2c92..00000000000000
--- a/src/libraries/System.Numerics.Tensors/tests/NativeMemory.cs
+++ /dev/null
@@ -1,108 +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 System.Runtime.InteropServices;
-using System.Runtime.CompilerServices;
-using System.Threading;
-
-namespace System.Numerics.Tensors.Tests
-{
-    public class NativeMemory<T> : MemoryManager<T>
-    {
-        private bool disposed = false;
-        private int refCount = 0;
-        private IntPtr memory;
-        private int length;
-
-        public NativeMemory(IntPtr memory, int length)
-        {
-            this.memory = memory;
-            this.length = length;
-        }
-
-        public unsafe NativeMemory(void* memory, int length)
-        {
-            this.memory = (IntPtr)memory;
-            this.length = length;
-        }
-
-        ~NativeMemory()
-        {
-            Dispose(false);
-        }
-
-        public static NativeMemory<T> Allocate(int length)
-        {
-            // typically this would call into a native method appropriate for the platform
-            // or the constructors above would be used to wrap the native pointer
-            IntPtr memory = Marshal.AllocHGlobal(Marshal.SizeOf<T>() * length);
-            return new NativeMemory<T>(memory, length);
-        }
-
-        public bool IsDisposed => disposed;
-
-        public unsafe override Span<T> GetSpan() => new Span<T>((void*)memory, length);
-
-        protected bool IsRetained => refCount > 0;
-
-        public override MemoryHandle Pin(int elementIndex = 0)
-        {
-            unsafe
-            {
-                Retain();
-                if ((uint)elementIndex > length) throw new ArgumentOutOfRangeException(nameof(elementIndex));
-                void* pointer = Unsafe.Add<T>((void*)memory, elementIndex);
-                return new MemoryHandle(pointer, default, this);
-            }
-        }
-
-        public bool Release()
-        {
-            int newRefCount = Interlocked.Decrement(ref refCount);
-
-            if (newRefCount < 0)
-            {
-                throw new InvalidOperationException("Unmatched Release/Retain");
-            }
-
-            return newRefCount != 0;
-        }
-
-        public void Retain()
-        {
-            if (disposed)
-            {
-                throw new ObjectDisposedException(nameof(NativeMemory<T>));
-            }
-
-            Interlocked.Increment(ref refCount);
-        }
-
-        protected override void Dispose(bool disposing)
-        {
-            if (disposed)
-            {
-                return;
-            }
-
-            // typically this would call into a native method appropriate for the platform
-            Marshal.FreeHGlobal(memory);
-            memory = IntPtr.Zero;
-
-            disposed = true;
-        }
-
-        protected override bool TryGetArray(out ArraySegment<T> arraySegment)
-        {
-            // cannot expose managed array
-            arraySegment = default;
-            return false;
-        }
-
-        public override void Unpin()
-        {
-            Release();
-        }
-    }
-}
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 042e4791b6a3d8..d78f1cd7e9e035 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
@@ -1,41 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  
   <PropertyGroup>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <TargetFrameworks>$(NetCoreAppCurrent);$(NetFrameworkMinimum)</TargetFrameworks>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
+
   <ItemGroup>
-    <Compile Include="NativeMemory.cs" />
-    <Compile Include="TensorArithmetic.cs">
-      <AutoGen>True</AutoGen>
-      <DesignTime>True</DesignTime>
-      <DependentUpon>TensorArithmetic.tt</DependentUpon>
-    </Compile>
-    <Compile Include="TensorExtensions.cs" />
-    <Compile Include="TensorOperations.cs">
-      <AutoGen>True</AutoGen>
-      <DesignTime>True</DesignTime>
-      <DependentUpon>TensorOperations.tt</DependentUpon>
-    </Compile>
-    <Compile Include="TensorTests.cs" />
-    <Compile Include="TensorTestsBase.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="TensorArithmetic.tt">
-      <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>TensorArithmetic.cs</LastGenOutput>
-    </None>
-    <None Include="TensorOperations.tt">
-      <Generator>TextTemplatingFileGenerator</Generator>
-      <LastGenOutput>TensorOperations.cs</LastGenOutput>
-    </None>
-    <None Include="TensorTemplate.ttinclude" />
+    <Compile Include="TensorPrimitivesTests.cs" />
   </ItemGroup>
+  
   <ItemGroup>
     <!-- Some internal types are needed, so we reference the implementation assembly, rather than the reference assembly. -->
     <ProjectReference Include="..\src\System.Numerics.Tensors.csproj" SkipUseReferenceAssembly="true" />
   </ItemGroup>
-  <ItemGroup>
-    <!-- enable the TextTemplating extension -->
-    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
-  </ItemGroup>
+
 </Project>
\ No newline at end of file
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorArithmetic.cs b/src/libraries/System.Numerics.Tensors/tests/TensorArithmetic.cs
deleted file mode 100644
index 6dae2ec6854252..00000000000000
--- a/src/libraries/System.Numerics.Tensors/tests/TensorArithmetic.cs
+++ /dev/null
@@ -1,16165 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Numerics.Tensors
-{
-    internal interface ITensorArithmetic<T>
-    {
-        T One { get; }
-        T Zero { get; }
-        void Add(Tensor<T> left, Tensor<T> right, Tensor<T> result);
-        void Add(Tensor<T> tensor, T scalar, Tensor<T> result);
-        void And(Tensor<T> left, Tensor<T> right, Tensor<T> result);
-        void And(Tensor<T> tensor, T scalar, Tensor<T> result);
-        void Contract(Tensor<T> left, Tensor<T> right, int[] leftAxes, int[] rightAxes, Tensor<T> result);
-        void Decrement(Tensor<T> tensor, Tensor<T> result);
-        void Divide(Tensor<T> left, Tensor<T> right, Tensor<T> result);
-        void Divide(Tensor<T> tensor, T scalar, Tensor<T> result);
-        void Equals(Tensor<T> left, Tensor<T> right, Tensor<bool> result);
-        void GreaterThan(Tensor<T> left, Tensor<T> right, Tensor<bool> result);
-        void GreaterThanOrEqual(Tensor<T> left, Tensor<T> right, Tensor<bool> result);
-        void Increment(Tensor<T> tensor, Tensor<T> result);
-        void LeftShift(Tensor<T> tensor, int value, Tensor<T> result);
-        void LessThan(Tensor<T> left, Tensor<T> right, Tensor<bool> result);
-        void LessThanOrEqual(Tensor<T> left, Tensor<T> right, Tensor<bool> result);
-        void Modulo(Tensor<T> left, Tensor<T> right, Tensor<T> result);
-        void Modulo(Tensor<T> tensor, T scalar, Tensor<T> result);
-        void Multiply(Tensor<T> left, Tensor<T> right, Tensor<T> result);
-        void Multiply(Tensor<T> tensor, T scalar, Tensor<T> result);
-        void NotEquals(Tensor<T> left, Tensor<T> right, Tensor<bool> result);
-        void Or(Tensor<T> left, Tensor<T> right, Tensor<T> result);
-        void Or(Tensor<T> tensor, T scalar, Tensor<T> result);
-        void RightShift(Tensor<T> tensor, int value, Tensor<T> result);
-        void Subtract(Tensor<T> left, Tensor<T> right, Tensor<T> result);
-        void Subtract(Tensor<T> tensor, T scalar, Tensor<T> result);
-        void UnaryMinus(Tensor<T> tensor, Tensor<T> result);
-        void UnaryPlus(Tensor<T> tensor, Tensor<T> result);
-        void Xor(Tensor<T> left, Tensor<T> right, Tensor<T> result);
-        void Xor(Tensor<T> tensor, T scalar, Tensor<T> result);
-    }
-
-    internal static class TensorArithmetic<T>
-    {
-        public static ITensorArithmetic<T> Instance => TensorArithmetic.GetArithmetic<T>();
-    }
-
-    internal static class TensorArithmetic
-    {
-        public static ITensorArithmetic<T> GetArithmetic<T>()
-        {
-            if (typeof(T) == typeof(bool))
-            {
-                return (ITensorArithmetic<T>)new BoolArithmetic();
-            }
-            else if (typeof(T) == typeof(byte))
-            {
-                return (ITensorArithmetic<T>)new ByteArithmetic();
-            }
-            else if (typeof(T) == typeof(char))
-            {
-                return (ITensorArithmetic<T>)new CharArithmetic();
-            }
-            else if (typeof(T) == typeof(decimal))
-            {
-                return (ITensorArithmetic<T>)new DecimalArithmetic();
-            }
-            else if (typeof(T) == typeof(double))
-            {
-                return (ITensorArithmetic<T>)new DoubleArithmetic();
-            }
-            else if (typeof(T) == typeof(float))
-            {
-                return (ITensorArithmetic<T>)new FloatArithmetic();
-            }
-            else if (typeof(T) == typeof(int))
-            {
-                return (ITensorArithmetic<T>)new IntArithmetic();
-            }
-            else if (typeof(T) == typeof(long))
-            {
-                return (ITensorArithmetic<T>)new LongArithmetic();
-            }
-            else if (typeof(T) == typeof(sbyte))
-            {
-                return (ITensorArithmetic<T>)new SByteArithmetic();
-            }
-            else if (typeof(T) == typeof(short))
-            {
-                return (ITensorArithmetic<T>)new ShortArithmetic();
-            }
-            else if (typeof(T) == typeof(uint))
-            {
-                return (ITensorArithmetic<T>)new UIntArithmetic();
-            }
-            else if (typeof(T) == typeof(ulong))
-            {
-                return (ITensorArithmetic<T>)new ULongArithmetic();
-            }
-            else if (typeof(T) == typeof(ushort))
-            {
-                return (ITensorArithmetic<T>)new UShortArithmetic();
-            }
-            return null;
-        }
-    }
-
-    internal class BoolArithmetic : ITensorArithmetic<bool>
-    {
-        public bool One => true;
-        public bool Zero => false;
-
-        public void Add(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Add(Tensor<bool> tensor, bool scalar, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void And(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (bool)(left[indices] & right[indices]);
-            }
-
-        }
-        public void And(Tensor<bool> tensor, bool scalar, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (bool)(tensor[indices] & scalar);
-            }
-
-        }
-        public void Contract(Tensor<bool> left, Tensor<bool> right, int[] leftAxes, int[] rightAxes, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Decrement(Tensor<bool> tensor, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Divide(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Divide(Tensor<bool> tensor, bool scalar, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Equals(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void GreaterThanOrEqual(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Increment(Tensor<bool> tensor, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LeftShift(Tensor<bool> tensor, int value, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LessThan(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LessThanOrEqual(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Modulo(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Modulo(Tensor<bool> tensor, bool scalar, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Multiply(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Multiply(Tensor<bool> tensor, bool scalar, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void NotEquals(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (bool)(left[indices] | right[indices]);
-            }
-
-        }
-        public void Or(Tensor<bool> tensor, bool scalar, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (bool)(tensor[indices] | scalar);
-            }
-
-        }
-        public void RightShift(Tensor<bool> tensor, int value, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Subtract(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Subtract(Tensor<bool> tensor, bool scalar, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void UnaryMinus(Tensor<bool> tensor, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void UnaryPlus(Tensor<bool> tensor, Tensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Xor(Tensor<bool> left, Tensor<bool> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (bool)(left[indices] ^ right[indices]);
-            }
-
-        }
-        public void Xor(Tensor<bool> tensor, bool scalar, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (bool)(tensor[indices] ^ scalar);
-            }
-
-        }
-
-        public void Add(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Add(DenseTensor<bool> tensor, bool scalar, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void And(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (bool)(leftSpan[i] & rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (bool)(leftSpan[op1Index] & rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void And(DenseTensor<bool> tensor, bool scalar, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (bool)(tensorSpan[i] & scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (bool)(tensorSpan[op1Index] & scalar);
-
-                }
-            }
-        }
-        public void Contract(DenseTensor<bool> left, DenseTensor<bool> right, int[] leftAxes, int[] rightAxes, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Decrement(DenseTensor<bool> tensor, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Divide(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Divide(DenseTensor<bool> tensor, bool scalar, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Equals(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void GreaterThanOrEqual(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Increment(DenseTensor<bool> tensor, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LeftShift(DenseTensor<bool> tensor, int value, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LessThan(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LessThanOrEqual(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Modulo(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Modulo(DenseTensor<bool> tensor, bool scalar, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Multiply(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Multiply(DenseTensor<bool> tensor, bool scalar, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void NotEquals(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (bool)(leftSpan[i] | rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (bool)(leftSpan[op1Index] | rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Or(DenseTensor<bool> tensor, bool scalar, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (bool)(tensorSpan[i] | scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (bool)(tensorSpan[op1Index] | scalar);
-
-                }
-            }
-        }
-        public void RightShift(DenseTensor<bool> tensor, int value, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Subtract(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Subtract(DenseTensor<bool> tensor, bool scalar, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void UnaryMinus(DenseTensor<bool> tensor, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void UnaryPlus(DenseTensor<bool> tensor, DenseTensor<bool> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Xor(DenseTensor<bool> left, DenseTensor<bool> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (bool)(leftSpan[i] ^ rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (bool)(leftSpan[op1Index] ^ rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<bool> tensor, bool scalar, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (bool)(tensorSpan[i] ^ scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (bool)(tensorSpan[op1Index] ^ scalar);
-
-                }
-            }
-        }
-    }
-    internal class ByteArithmetic : ITensorArithmetic<byte>
-    {
-        public byte One => 1;
-        public byte Zero => 0;
-
-        public void Add(Tensor<byte> left, Tensor<byte> right, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<byte> tensor, byte scalar, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<byte> left, Tensor<byte> right, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(left[indices] & right[indices]);
-            }
-
-        }
-        public void And(Tensor<byte> tensor, byte scalar, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(tensor[indices] & scalar);
-            }
-
-        }
-        public void Contract(Tensor<byte> left, Tensor<byte> right, int[] leftAxes, int[] rightAxes, Tensor<byte> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                byte sum = (byte)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (byte)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<byte> tensor, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<byte> left, Tensor<byte> right, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<byte> tensor, byte scalar, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<byte> left, Tensor<byte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<byte> left, Tensor<byte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<byte> left, Tensor<byte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<byte> tensor, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<byte> tensor, int value, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(tensor[indices] << value);
-            }
-
-        }
-        public void LessThan(Tensor<byte> left, Tensor<byte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<byte> left, Tensor<byte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<byte> left, Tensor<byte> right, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<byte> tensor, byte scalar, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<byte> left, Tensor<byte> right, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<byte> tensor, byte scalar, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<byte> left, Tensor<byte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<byte> left, Tensor<byte> right, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(left[indices] | right[indices]);
-            }
-
-        }
-        public void Or(Tensor<byte> tensor, byte scalar, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(tensor[indices] | scalar);
-            }
-
-        }
-        public void RightShift(Tensor<byte> tensor, int value, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(tensor[indices] >> value);
-            }
-
-        }
-        public void Subtract(Tensor<byte> left, Tensor<byte> right, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<byte> tensor, byte scalar, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<byte> tensor, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)-tensor[indices];
-            }
-
-        }
-        public void UnaryPlus(Tensor<byte> tensor, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<byte> left, Tensor<byte> right, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(left[indices] ^ right[indices]);
-            }
-
-        }
-        public void Xor(Tensor<byte> tensor, byte scalar, Tensor<byte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (byte)(tensor[indices] ^ scalar);
-            }
-
-        }
-
-        public void Add(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<byte> tensor, byte scalar, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(leftSpan[i] & rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(leftSpan[op1Index] & rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void And(DenseTensor<byte> tensor, byte scalar, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(tensorSpan[i] & scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(tensorSpan[op1Index] & scalar);
-
-                }
-            }
-        }
-        public void Contract(DenseTensor<byte> left, DenseTensor<byte> right, int[] leftAxes, int[] rightAxes, DenseTensor<byte> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                byte sum = (byte)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (byte)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<byte> tensor, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<byte> tensor, byte scalar, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<byte> tensor, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<byte> tensor, int value, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(tensorSpan[i] << value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(tensorSpan[op1Index] << value);
-
-                }
-            }
-        }
-        public void LessThan(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<byte> tensor, byte scalar, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<byte> tensor, byte scalar, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(leftSpan[i] | rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(leftSpan[op1Index] | rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Or(DenseTensor<byte> tensor, byte scalar, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(tensorSpan[i] | scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(tensorSpan[op1Index] | scalar);
-
-                }
-            }
-        }
-        public void RightShift(DenseTensor<byte> tensor, int value, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(tensorSpan[i] >> value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(tensorSpan[op1Index] >> value);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<byte> tensor, byte scalar, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<byte> tensor, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)-tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)-tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void UnaryPlus(DenseTensor<byte> tensor, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<byte> left, DenseTensor<byte> right, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(leftSpan[i] ^ rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(leftSpan[op1Index] ^ rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<byte> tensor, byte scalar, DenseTensor<byte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (byte)(tensorSpan[i] ^ scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (byte)(tensorSpan[op1Index] ^ scalar);
-
-                }
-            }
-        }
-    }
-    internal class CharArithmetic : ITensorArithmetic<char>
-    {
-        public char One => (char)1;
-        public char Zero => (char)0;
-
-        public void Add(Tensor<char> left, Tensor<char> right, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<char> tensor, char scalar, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<char> left, Tensor<char> right, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(left[indices] & right[indices]);
-            }
-
-        }
-        public void And(Tensor<char> tensor, char scalar, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(tensor[indices] & scalar);
-            }
-
-        }
-        public void Contract(Tensor<char> left, Tensor<char> right, int[] leftAxes, int[] rightAxes, Tensor<char> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                char sum = (char)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (char)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<char> tensor, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<char> left, Tensor<char> right, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<char> tensor, char scalar, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<char> left, Tensor<char> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<char> left, Tensor<char> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<char> left, Tensor<char> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<char> tensor, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<char> tensor, int value, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(tensor[indices] << value);
-            }
-
-        }
-        public void LessThan(Tensor<char> left, Tensor<char> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<char> left, Tensor<char> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<char> left, Tensor<char> right, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<char> tensor, char scalar, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<char> left, Tensor<char> right, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<char> tensor, char scalar, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<char> left, Tensor<char> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<char> left, Tensor<char> right, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(left[indices] | right[indices]);
-            }
-
-        }
-        public void Or(Tensor<char> tensor, char scalar, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(tensor[indices] | scalar);
-            }
-
-        }
-        public void RightShift(Tensor<char> tensor, int value, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(tensor[indices] >> value);
-            }
-
-        }
-        public void Subtract(Tensor<char> left, Tensor<char> right, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<char> tensor, char scalar, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<char> tensor, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)-tensor[indices];
-            }
-
-        }
-        public void UnaryPlus(Tensor<char> tensor, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<char> left, Tensor<char> right, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(left[indices] ^ right[indices]);
-            }
-
-        }
-        public void Xor(Tensor<char> tensor, char scalar, Tensor<char> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (char)(tensor[indices] ^ scalar);
-            }
-
-        }
-
-        public void Add(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<char> tensor, char scalar, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(leftSpan[i] & rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(leftSpan[op1Index] & rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void And(DenseTensor<char> tensor, char scalar, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(tensorSpan[i] & scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(tensorSpan[op1Index] & scalar);
-
-                }
-            }
-        }
-        public void Contract(DenseTensor<char> left, DenseTensor<char> right, int[] leftAxes, int[] rightAxes, DenseTensor<char> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                char sum = (char)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (char)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<char> tensor, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<char> tensor, char scalar, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<char> tensor, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<char> tensor, int value, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(tensorSpan[i] << value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(tensorSpan[op1Index] << value);
-
-                }
-            }
-        }
-        public void LessThan(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<char> tensor, char scalar, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<char> tensor, char scalar, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(leftSpan[i] | rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(leftSpan[op1Index] | rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Or(DenseTensor<char> tensor, char scalar, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(tensorSpan[i] | scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(tensorSpan[op1Index] | scalar);
-
-                }
-            }
-        }
-        public void RightShift(DenseTensor<char> tensor, int value, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(tensorSpan[i] >> value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(tensorSpan[op1Index] >> value);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<char> tensor, char scalar, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<char> tensor, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)-tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)-tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void UnaryPlus(DenseTensor<char> tensor, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<char> left, DenseTensor<char> right, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(leftSpan[i] ^ rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(leftSpan[op1Index] ^ rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<char> tensor, char scalar, DenseTensor<char> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (char)(tensorSpan[i] ^ scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (char)(tensorSpan[op1Index] ^ scalar);
-
-                }
-            }
-        }
-    }
-    internal class DecimalArithmetic : ITensorArithmetic<decimal>
-    {
-        public decimal One => 1;
-        public decimal Zero => 0;
-
-        public void Add(Tensor<decimal> left, Tensor<decimal> right, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<decimal> tensor, decimal scalar, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<decimal> left, Tensor<decimal> right, Tensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void And(Tensor<decimal> tensor, decimal scalar, Tensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Contract(Tensor<decimal> left, Tensor<decimal> right, int[] leftAxes, int[] rightAxes, Tensor<decimal> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                decimal sum = (decimal)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (decimal)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<decimal> tensor, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<decimal> left, Tensor<decimal> right, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<decimal> tensor, decimal scalar, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<decimal> left, Tensor<decimal> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<decimal> left, Tensor<decimal> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<decimal> left, Tensor<decimal> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<decimal> tensor, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<decimal> tensor, int value, Tensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LessThan(Tensor<decimal> left, Tensor<decimal> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<decimal> left, Tensor<decimal> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<decimal> left, Tensor<decimal> right, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<decimal> tensor, decimal scalar, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<decimal> left, Tensor<decimal> right, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<decimal> tensor, decimal scalar, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<decimal> left, Tensor<decimal> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<decimal> left, Tensor<decimal> right, Tensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Or(Tensor<decimal> tensor, decimal scalar, Tensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void RightShift(Tensor<decimal> tensor, int value, Tensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Subtract(Tensor<decimal> left, Tensor<decimal> right, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<decimal> tensor, decimal scalar, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<decimal> tensor, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)-tensor[indices];
-            }
-
-        }
-        public void UnaryPlus(Tensor<decimal> tensor, Tensor<decimal> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (decimal)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<decimal> left, Tensor<decimal> right, Tensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Xor(Tensor<decimal> tensor, decimal scalar, Tensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-
-        public void Add(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<decimal> tensor, decimal scalar, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void And(DenseTensor<decimal> tensor, decimal scalar, DenseTensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Contract(DenseTensor<decimal> left, DenseTensor<decimal> right, int[] leftAxes, int[] rightAxes, DenseTensor<decimal> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                decimal sum = (decimal)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (decimal)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<decimal> tensor, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<decimal> tensor, decimal scalar, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<decimal> tensor, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<decimal> tensor, int value, DenseTensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LessThan(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<decimal> tensor, decimal scalar, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<decimal> tensor, decimal scalar, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Or(DenseTensor<decimal> tensor, decimal scalar, DenseTensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void RightShift(DenseTensor<decimal> tensor, int value, DenseTensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Subtract(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<decimal> tensor, decimal scalar, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<decimal> tensor, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)-tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)-tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void UnaryPlus(DenseTensor<decimal> tensor, DenseTensor<decimal> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (decimal)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (decimal)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<decimal> left, DenseTensor<decimal> right, DenseTensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Xor(DenseTensor<decimal> tensor, decimal scalar, DenseTensor<decimal> result)
-        {
-            throw new NotSupportedException();
-        }
-    }
-    internal class DoubleArithmetic : ITensorArithmetic<double>
-    {
-        public double One => 1.0;
-        public double Zero => 0;
-
-        public void Add(Tensor<double> left, Tensor<double> right, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<double> tensor, double scalar, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<double> left, Tensor<double> right, Tensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void And(Tensor<double> tensor, double scalar, Tensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Contract(Tensor<double> left, Tensor<double> right, int[] leftAxes, int[] rightAxes, Tensor<double> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                double sum = (double)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (double)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<double> tensor, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<double> left, Tensor<double> right, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<double> tensor, double scalar, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<double> left, Tensor<double> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<double> left, Tensor<double> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<double> left, Tensor<double> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<double> tensor, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<double> tensor, int value, Tensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LessThan(Tensor<double> left, Tensor<double> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<double> left, Tensor<double> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<double> left, Tensor<double> right, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<double> tensor, double scalar, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<double> left, Tensor<double> right, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<double> tensor, double scalar, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<double> left, Tensor<double> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<double> left, Tensor<double> right, Tensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Or(Tensor<double> tensor, double scalar, Tensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void RightShift(Tensor<double> tensor, int value, Tensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Subtract(Tensor<double> left, Tensor<double> right, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<double> tensor, double scalar, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<double> tensor, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)-tensor[indices];
-            }
-
-        }
-        public void UnaryPlus(Tensor<double> tensor, Tensor<double> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (double)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<double> left, Tensor<double> right, Tensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Xor(Tensor<double> tensor, double scalar, Tensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-
-        public void Add(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<double> tensor, double scalar, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void And(DenseTensor<double> tensor, double scalar, DenseTensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Contract(DenseTensor<double> left, DenseTensor<double> right, int[] leftAxes, int[] rightAxes, DenseTensor<double> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                double sum = (double)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (double)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<double> tensor, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<double> tensor, double scalar, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<double> tensor, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<double> tensor, int value, DenseTensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LessThan(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<double> tensor, double scalar, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<double> tensor, double scalar, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Or(DenseTensor<double> tensor, double scalar, DenseTensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void RightShift(DenseTensor<double> tensor, int value, DenseTensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Subtract(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<double> tensor, double scalar, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<double> tensor, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)-tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)-tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void UnaryPlus(DenseTensor<double> tensor, DenseTensor<double> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (double)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (double)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<double> left, DenseTensor<double> right, DenseTensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Xor(DenseTensor<double> tensor, double scalar, DenseTensor<double> result)
-        {
-            throw new NotSupportedException();
-        }
-    }
-    internal class FloatArithmetic : ITensorArithmetic<float>
-    {
-        public float One => 1.0f;
-        public float Zero => 0;
-
-        public void Add(Tensor<float> left, Tensor<float> right, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<float> tensor, float scalar, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<float> left, Tensor<float> right, Tensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void And(Tensor<float> tensor, float scalar, Tensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Contract(Tensor<float> left, Tensor<float> right, int[] leftAxes, int[] rightAxes, Tensor<float> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                float sum = (float)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (float)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<float> tensor, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<float> left, Tensor<float> right, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<float> tensor, float scalar, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<float> left, Tensor<float> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<float> left, Tensor<float> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<float> left, Tensor<float> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<float> tensor, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<float> tensor, int value, Tensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LessThan(Tensor<float> left, Tensor<float> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<float> left, Tensor<float> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<float> left, Tensor<float> right, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<float> tensor, float scalar, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<float> left, Tensor<float> right, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<float> tensor, float scalar, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<float> left, Tensor<float> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<float> left, Tensor<float> right, Tensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Or(Tensor<float> tensor, float scalar, Tensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void RightShift(Tensor<float> tensor, int value, Tensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Subtract(Tensor<float> left, Tensor<float> right, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<float> tensor, float scalar, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<float> tensor, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)-tensor[indices];
-            }
-
-        }
-        public void UnaryPlus(Tensor<float> tensor, Tensor<float> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (float)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<float> left, Tensor<float> right, Tensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Xor(Tensor<float> tensor, float scalar, Tensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-
-        public void Add(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<float> tensor, float scalar, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void And(DenseTensor<float> tensor, float scalar, DenseTensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Contract(DenseTensor<float> left, DenseTensor<float> right, int[] leftAxes, int[] rightAxes, DenseTensor<float> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                float sum = (float)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (float)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<float> tensor, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<float> tensor, float scalar, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<float> tensor, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<float> tensor, int value, DenseTensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void LessThan(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<float> tensor, float scalar, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<float> tensor, float scalar, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Or(DenseTensor<float> tensor, float scalar, DenseTensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void RightShift(DenseTensor<float> tensor, int value, DenseTensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Subtract(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<float> tensor, float scalar, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<float> tensor, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)-tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)-tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void UnaryPlus(DenseTensor<float> tensor, DenseTensor<float> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (float)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (float)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<float> left, DenseTensor<float> right, DenseTensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void Xor(DenseTensor<float> tensor, float scalar, DenseTensor<float> result)
-        {
-            throw new NotSupportedException();
-        }
-    }
-    internal class IntArithmetic : ITensorArithmetic<int>
-    {
-        public int One => 1;
-        public int Zero => 0;
-
-        public void Add(Tensor<int> left, Tensor<int> right, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<int> tensor, int scalar, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<int> left, Tensor<int> right, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(left[indices] & right[indices]);
-            }
-
-        }
-        public void And(Tensor<int> tensor, int scalar, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(tensor[indices] & scalar);
-            }
-
-        }
-        public void Contract(Tensor<int> left, Tensor<int> right, int[] leftAxes, int[] rightAxes, Tensor<int> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                int sum = (int)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (int)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<int> tensor, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<int> left, Tensor<int> right, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<int> tensor, int scalar, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<int> left, Tensor<int> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<int> left, Tensor<int> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<int> left, Tensor<int> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<int> tensor, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<int> tensor, int value, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(tensor[indices] << value);
-            }
-
-        }
-        public void LessThan(Tensor<int> left, Tensor<int> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<int> left, Tensor<int> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<int> left, Tensor<int> right, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<int> tensor, int scalar, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<int> left, Tensor<int> right, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<int> tensor, int scalar, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<int> left, Tensor<int> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<int> left, Tensor<int> right, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(left[indices] | right[indices]);
-            }
-
-        }
-        public void Or(Tensor<int> tensor, int scalar, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(tensor[indices] | scalar);
-            }
-
-        }
-        public void RightShift(Tensor<int> tensor, int value, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(tensor[indices] >> value);
-            }
-
-        }
-        public void Subtract(Tensor<int> left, Tensor<int> right, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<int> tensor, int scalar, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<int> tensor, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)-tensor[indices];
-            }
-
-        }
-        public void UnaryPlus(Tensor<int> tensor, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<int> left, Tensor<int> right, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(left[indices] ^ right[indices]);
-            }
-
-        }
-        public void Xor(Tensor<int> tensor, int scalar, Tensor<int> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (int)(tensor[indices] ^ scalar);
-            }
-
-        }
-
-        public void Add(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<int> tensor, int scalar, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(leftSpan[i] & rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(leftSpan[op1Index] & rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void And(DenseTensor<int> tensor, int scalar, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(tensorSpan[i] & scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(tensorSpan[op1Index] & scalar);
-
-                }
-            }
-        }
-        public void Contract(DenseTensor<int> left, DenseTensor<int> right, int[] leftAxes, int[] rightAxes, DenseTensor<int> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                int sum = (int)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (int)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<int> tensor, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<int> tensor, int scalar, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<int> tensor, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<int> tensor, int value, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(tensorSpan[i] << value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(tensorSpan[op1Index] << value);
-
-                }
-            }
-        }
-        public void LessThan(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<int> tensor, int scalar, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<int> tensor, int scalar, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(leftSpan[i] | rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(leftSpan[op1Index] | rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Or(DenseTensor<int> tensor, int scalar, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(tensorSpan[i] | scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(tensorSpan[op1Index] | scalar);
-
-                }
-            }
-        }
-        public void RightShift(DenseTensor<int> tensor, int value, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(tensorSpan[i] >> value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(tensorSpan[op1Index] >> value);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<int> tensor, int scalar, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<int> tensor, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)-tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)-tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void UnaryPlus(DenseTensor<int> tensor, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<int> left, DenseTensor<int> right, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(leftSpan[i] ^ rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(leftSpan[op1Index] ^ rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<int> tensor, int scalar, DenseTensor<int> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (int)(tensorSpan[i] ^ scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (int)(tensorSpan[op1Index] ^ scalar);
-
-                }
-            }
-        }
-    }
-    internal class LongArithmetic : ITensorArithmetic<long>
-    {
-        public long One => 1;
-        public long Zero => 0;
-
-        public void Add(Tensor<long> left, Tensor<long> right, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<long> tensor, long scalar, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<long> left, Tensor<long> right, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(left[indices] & right[indices]);
-            }
-
-        }
-        public void And(Tensor<long> tensor, long scalar, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(tensor[indices] & scalar);
-            }
-
-        }
-        public void Contract(Tensor<long> left, Tensor<long> right, int[] leftAxes, int[] rightAxes, Tensor<long> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                long sum = (long)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (long)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<long> tensor, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<long> left, Tensor<long> right, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<long> tensor, long scalar, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<long> left, Tensor<long> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<long> left, Tensor<long> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<long> left, Tensor<long> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<long> tensor, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<long> tensor, int value, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(tensor[indices] << value);
-            }
-
-        }
-        public void LessThan(Tensor<long> left, Tensor<long> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<long> left, Tensor<long> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<long> left, Tensor<long> right, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<long> tensor, long scalar, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<long> left, Tensor<long> right, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<long> tensor, long scalar, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<long> left, Tensor<long> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<long> left, Tensor<long> right, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(left[indices] | right[indices]);
-            }
-
-        }
-        public void Or(Tensor<long> tensor, long scalar, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(tensor[indices] | scalar);
-            }
-
-        }
-        public void RightShift(Tensor<long> tensor, int value, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(tensor[indices] >> value);
-            }
-
-        }
-        public void Subtract(Tensor<long> left, Tensor<long> right, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<long> tensor, long scalar, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<long> tensor, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)-tensor[indices];
-            }
-
-        }
-        public void UnaryPlus(Tensor<long> tensor, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<long> left, Tensor<long> right, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(left[indices] ^ right[indices]);
-            }
-
-        }
-        public void Xor(Tensor<long> tensor, long scalar, Tensor<long> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (long)(tensor[indices] ^ scalar);
-            }
-
-        }
-
-        public void Add(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<long> tensor, long scalar, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(leftSpan[i] & rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(leftSpan[op1Index] & rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void And(DenseTensor<long> tensor, long scalar, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(tensorSpan[i] & scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(tensorSpan[op1Index] & scalar);
-
-                }
-            }
-        }
-        public void Contract(DenseTensor<long> left, DenseTensor<long> right, int[] leftAxes, int[] rightAxes, DenseTensor<long> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                long sum = (long)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (long)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<long> tensor, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<long> tensor, long scalar, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<long> tensor, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<long> tensor, int value, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(tensorSpan[i] << value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(tensorSpan[op1Index] << value);
-
-                }
-            }
-        }
-        public void LessThan(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<long> tensor, long scalar, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<long> tensor, long scalar, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(leftSpan[i] | rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(leftSpan[op1Index] | rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Or(DenseTensor<long> tensor, long scalar, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(tensorSpan[i] | scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(tensorSpan[op1Index] | scalar);
-
-                }
-            }
-        }
-        public void RightShift(DenseTensor<long> tensor, int value, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(tensorSpan[i] >> value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(tensorSpan[op1Index] >> value);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<long> tensor, long scalar, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<long> tensor, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)-tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)-tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void UnaryPlus(DenseTensor<long> tensor, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<long> left, DenseTensor<long> right, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(leftSpan[i] ^ rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(leftSpan[op1Index] ^ rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<long> tensor, long scalar, DenseTensor<long> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (long)(tensorSpan[i] ^ scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (long)(tensorSpan[op1Index] ^ scalar);
-
-                }
-            }
-        }
-    }
-    internal class SByteArithmetic : ITensorArithmetic<sbyte>
-    {
-        public sbyte One => 1;
-        public sbyte Zero => 0;
-
-        public void Add(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<sbyte> tensor, sbyte scalar, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(left[indices] & right[indices]);
-            }
-
-        }
-        public void And(Tensor<sbyte> tensor, sbyte scalar, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(tensor[indices] & scalar);
-            }
-
-        }
-        public void Contract(Tensor<sbyte> left, Tensor<sbyte> right, int[] leftAxes, int[] rightAxes, Tensor<sbyte> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                sbyte sum = (sbyte)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (sbyte)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<sbyte> tensor, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<sbyte> tensor, sbyte scalar, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<sbyte> tensor, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<sbyte> tensor, int value, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(tensor[indices] << value);
-            }
-
-        }
-        public void LessThan(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<sbyte> tensor, sbyte scalar, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<sbyte> tensor, sbyte scalar, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(left[indices] | right[indices]);
-            }
-
-        }
-        public void Or(Tensor<sbyte> tensor, sbyte scalar, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(tensor[indices] | scalar);
-            }
-
-        }
-        public void RightShift(Tensor<sbyte> tensor, int value, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(tensor[indices] >> value);
-            }
-
-        }
-        public void Subtract(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<sbyte> tensor, sbyte scalar, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<sbyte> tensor, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)-tensor[indices];
-            }
-
-        }
-        public void UnaryPlus(Tensor<sbyte> tensor, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<sbyte> left, Tensor<sbyte> right, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(left[indices] ^ right[indices]);
-            }
-
-        }
-        public void Xor(Tensor<sbyte> tensor, sbyte scalar, Tensor<sbyte> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (sbyte)(tensor[indices] ^ scalar);
-            }
-
-        }
-
-        public void Add(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<sbyte> tensor, sbyte scalar, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(leftSpan[i] & rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(leftSpan[op1Index] & rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void And(DenseTensor<sbyte> tensor, sbyte scalar, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(tensorSpan[i] & scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(tensorSpan[op1Index] & scalar);
-
-                }
-            }
-        }
-        public void Contract(DenseTensor<sbyte> left, DenseTensor<sbyte> right, int[] leftAxes, int[] rightAxes, DenseTensor<sbyte> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                sbyte sum = (sbyte)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (sbyte)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<sbyte> tensor, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<sbyte> tensor, sbyte scalar, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<sbyte> tensor, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<sbyte> tensor, int value, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(tensorSpan[i] << value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(tensorSpan[op1Index] << value);
-
-                }
-            }
-        }
-        public void LessThan(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<sbyte> tensor, sbyte scalar, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<sbyte> tensor, sbyte scalar, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(leftSpan[i] | rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(leftSpan[op1Index] | rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Or(DenseTensor<sbyte> tensor, sbyte scalar, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(tensorSpan[i] | scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(tensorSpan[op1Index] | scalar);
-
-                }
-            }
-        }
-        public void RightShift(DenseTensor<sbyte> tensor, int value, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(tensorSpan[i] >> value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(tensorSpan[op1Index] >> value);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<sbyte> tensor, sbyte scalar, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<sbyte> tensor, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)-tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)-tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void UnaryPlus(DenseTensor<sbyte> tensor, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<sbyte> left, DenseTensor<sbyte> right, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(leftSpan[i] ^ rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(leftSpan[op1Index] ^ rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<sbyte> tensor, sbyte scalar, DenseTensor<sbyte> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (sbyte)(tensorSpan[i] ^ scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (sbyte)(tensorSpan[op1Index] ^ scalar);
-
-                }
-            }
-        }
-    }
-    internal class ShortArithmetic : ITensorArithmetic<short>
-    {
-        public short One => 1;
-        public short Zero => 0;
-
-        public void Add(Tensor<short> left, Tensor<short> right, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<short> tensor, short scalar, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<short> left, Tensor<short> right, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(left[indices] & right[indices]);
-            }
-
-        }
-        public void And(Tensor<short> tensor, short scalar, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(tensor[indices] & scalar);
-            }
-
-        }
-        public void Contract(Tensor<short> left, Tensor<short> right, int[] leftAxes, int[] rightAxes, Tensor<short> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                short sum = (short)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (short)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<short> tensor, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<short> left, Tensor<short> right, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<short> tensor, short scalar, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<short> left, Tensor<short> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<short> left, Tensor<short> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<short> left, Tensor<short> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<short> tensor, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<short> tensor, int value, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(tensor[indices] << value);
-            }
-
-        }
-        public void LessThan(Tensor<short> left, Tensor<short> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<short> left, Tensor<short> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<short> left, Tensor<short> right, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<short> tensor, short scalar, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<short> left, Tensor<short> right, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<short> tensor, short scalar, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<short> left, Tensor<short> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<short> left, Tensor<short> right, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(left[indices] | right[indices]);
-            }
-
-        }
-        public void Or(Tensor<short> tensor, short scalar, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(tensor[indices] | scalar);
-            }
-
-        }
-        public void RightShift(Tensor<short> tensor, int value, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(tensor[indices] >> value);
-            }
-
-        }
-        public void Subtract(Tensor<short> left, Tensor<short> right, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<short> tensor, short scalar, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<short> tensor, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)-tensor[indices];
-            }
-
-        }
-        public void UnaryPlus(Tensor<short> tensor, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<short> left, Tensor<short> right, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(left[indices] ^ right[indices]);
-            }
-
-        }
-        public void Xor(Tensor<short> tensor, short scalar, Tensor<short> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (short)(tensor[indices] ^ scalar);
-            }
-
-        }
-
-        public void Add(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<short> tensor, short scalar, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(leftSpan[i] & rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(leftSpan[op1Index] & rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void And(DenseTensor<short> tensor, short scalar, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(tensorSpan[i] & scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(tensorSpan[op1Index] & scalar);
-
-                }
-            }
-        }
-        public void Contract(DenseTensor<short> left, DenseTensor<short> right, int[] leftAxes, int[] rightAxes, DenseTensor<short> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                short sum = (short)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (short)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<short> tensor, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<short> tensor, short scalar, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<short> tensor, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<short> tensor, int value, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(tensorSpan[i] << value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(tensorSpan[op1Index] << value);
-
-                }
-            }
-        }
-        public void LessThan(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<short> tensor, short scalar, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<short> tensor, short scalar, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(leftSpan[i] | rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(leftSpan[op1Index] | rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Or(DenseTensor<short> tensor, short scalar, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(tensorSpan[i] | scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(tensorSpan[op1Index] | scalar);
-
-                }
-            }
-        }
-        public void RightShift(DenseTensor<short> tensor, int value, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(tensorSpan[i] >> value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(tensorSpan[op1Index] >> value);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<short> tensor, short scalar, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<short> tensor, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)-tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)-tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void UnaryPlus(DenseTensor<short> tensor, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<short> left, DenseTensor<short> right, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(leftSpan[i] ^ rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(leftSpan[op1Index] ^ rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<short> tensor, short scalar, DenseTensor<short> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (short)(tensorSpan[i] ^ scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (short)(tensorSpan[op1Index] ^ scalar);
-
-                }
-            }
-        }
-    }
-    internal class UIntArithmetic : ITensorArithmetic<uint>
-    {
-        public uint One => 1;
-        public uint Zero => 0;
-
-        public void Add(Tensor<uint> left, Tensor<uint> right, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<uint> tensor, uint scalar, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<uint> left, Tensor<uint> right, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(left[indices] & right[indices]);
-            }
-
-        }
-        public void And(Tensor<uint> tensor, uint scalar, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(tensor[indices] & scalar);
-            }
-
-        }
-        public void Contract(Tensor<uint> left, Tensor<uint> right, int[] leftAxes, int[] rightAxes, Tensor<uint> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                uint sum = (uint)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (uint)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<uint> tensor, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<uint> left, Tensor<uint> right, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<uint> tensor, uint scalar, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<uint> left, Tensor<uint> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<uint> left, Tensor<uint> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<uint> left, Tensor<uint> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<uint> tensor, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<uint> tensor, int value, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(tensor[indices] << value);
-            }
-
-        }
-        public void LessThan(Tensor<uint> left, Tensor<uint> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<uint> left, Tensor<uint> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<uint> left, Tensor<uint> right, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<uint> tensor, uint scalar, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<uint> left, Tensor<uint> right, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<uint> tensor, uint scalar, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<uint> left, Tensor<uint> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<uint> left, Tensor<uint> right, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(left[indices] | right[indices]);
-            }
-
-        }
-        public void Or(Tensor<uint> tensor, uint scalar, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(tensor[indices] | scalar);
-            }
-
-        }
-        public void RightShift(Tensor<uint> tensor, int value, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(tensor[indices] >> value);
-            }
-
-        }
-        public void Subtract(Tensor<uint> left, Tensor<uint> right, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<uint> tensor, uint scalar, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<uint> tensor, Tensor<uint> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void UnaryPlus(Tensor<uint> tensor, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<uint> left, Tensor<uint> right, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(left[indices] ^ right[indices]);
-            }
-
-        }
-        public void Xor(Tensor<uint> tensor, uint scalar, Tensor<uint> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (uint)(tensor[indices] ^ scalar);
-            }
-
-        }
-
-        public void Add(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<uint> tensor, uint scalar, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(leftSpan[i] & rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(leftSpan[op1Index] & rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void And(DenseTensor<uint> tensor, uint scalar, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(tensorSpan[i] & scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(tensorSpan[op1Index] & scalar);
-
-                }
-            }
-        }
-        public void Contract(DenseTensor<uint> left, DenseTensor<uint> right, int[] leftAxes, int[] rightAxes, DenseTensor<uint> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                uint sum = (uint)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (uint)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<uint> tensor, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<uint> tensor, uint scalar, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<uint> tensor, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<uint> tensor, int value, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(tensorSpan[i] << value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(tensorSpan[op1Index] << value);
-
-                }
-            }
-        }
-        public void LessThan(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<uint> tensor, uint scalar, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<uint> tensor, uint scalar, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(leftSpan[i] | rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(leftSpan[op1Index] | rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Or(DenseTensor<uint> tensor, uint scalar, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(tensorSpan[i] | scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(tensorSpan[op1Index] | scalar);
-
-                }
-            }
-        }
-        public void RightShift(DenseTensor<uint> tensor, int value, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(tensorSpan[i] >> value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(tensorSpan[op1Index] >> value);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<uint> tensor, uint scalar, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<uint> tensor, DenseTensor<uint> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void UnaryPlus(DenseTensor<uint> tensor, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<uint> left, DenseTensor<uint> right, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(leftSpan[i] ^ rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(leftSpan[op1Index] ^ rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<uint> tensor, uint scalar, DenseTensor<uint> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (uint)(tensorSpan[i] ^ scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (uint)(tensorSpan[op1Index] ^ scalar);
-
-                }
-            }
-        }
-    }
-    internal class ULongArithmetic : ITensorArithmetic<ulong>
-    {
-        public ulong One => 1;
-        public ulong Zero => 0;
-
-        public void Add(Tensor<ulong> left, Tensor<ulong> right, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<ulong> tensor, ulong scalar, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<ulong> left, Tensor<ulong> right, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(left[indices] & right[indices]);
-            }
-
-        }
-        public void And(Tensor<ulong> tensor, ulong scalar, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(tensor[indices] & scalar);
-            }
-
-        }
-        public void Contract(Tensor<ulong> left, Tensor<ulong> right, int[] leftAxes, int[] rightAxes, Tensor<ulong> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                ulong sum = (ulong)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (ulong)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<ulong> tensor, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<ulong> left, Tensor<ulong> right, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<ulong> tensor, ulong scalar, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<ulong> left, Tensor<ulong> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<ulong> left, Tensor<ulong> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<ulong> left, Tensor<ulong> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<ulong> tensor, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<ulong> tensor, int value, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(tensor[indices] << value);
-            }
-
-        }
-        public void LessThan(Tensor<ulong> left, Tensor<ulong> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<ulong> left, Tensor<ulong> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<ulong> left, Tensor<ulong> right, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<ulong> tensor, ulong scalar, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<ulong> left, Tensor<ulong> right, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<ulong> tensor, ulong scalar, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<ulong> left, Tensor<ulong> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<ulong> left, Tensor<ulong> right, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(left[indices] | right[indices]);
-            }
-
-        }
-        public void Or(Tensor<ulong> tensor, ulong scalar, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(tensor[indices] | scalar);
-            }
-
-        }
-        public void RightShift(Tensor<ulong> tensor, int value, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(tensor[indices] >> value);
-            }
-
-        }
-        public void Subtract(Tensor<ulong> left, Tensor<ulong> right, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<ulong> tensor, ulong scalar, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<ulong> tensor, Tensor<ulong> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void UnaryPlus(Tensor<ulong> tensor, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<ulong> left, Tensor<ulong> right, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(left[indices] ^ right[indices]);
-            }
-
-        }
-        public void Xor(Tensor<ulong> tensor, ulong scalar, Tensor<ulong> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ulong)(tensor[indices] ^ scalar);
-            }
-
-        }
-
-        public void Add(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<ulong> tensor, ulong scalar, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(leftSpan[i] & rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(leftSpan[op1Index] & rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void And(DenseTensor<ulong> tensor, ulong scalar, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(tensorSpan[i] & scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(tensorSpan[op1Index] & scalar);
-
-                }
-            }
-        }
-        public void Contract(DenseTensor<ulong> left, DenseTensor<ulong> right, int[] leftAxes, int[] rightAxes, DenseTensor<ulong> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                ulong sum = (ulong)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (ulong)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<ulong> tensor, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<ulong> tensor, ulong scalar, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<ulong> tensor, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<ulong> tensor, int value, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(tensorSpan[i] << value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(tensorSpan[op1Index] << value);
-
-                }
-            }
-        }
-        public void LessThan(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<ulong> tensor, ulong scalar, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<ulong> tensor, ulong scalar, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(leftSpan[i] | rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(leftSpan[op1Index] | rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Or(DenseTensor<ulong> tensor, ulong scalar, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(tensorSpan[i] | scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(tensorSpan[op1Index] | scalar);
-
-                }
-            }
-        }
-        public void RightShift(DenseTensor<ulong> tensor, int value, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(tensorSpan[i] >> value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(tensorSpan[op1Index] >> value);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<ulong> tensor, ulong scalar, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<ulong> tensor, DenseTensor<ulong> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void UnaryPlus(DenseTensor<ulong> tensor, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<ulong> left, DenseTensor<ulong> right, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(leftSpan[i] ^ rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(leftSpan[op1Index] ^ rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<ulong> tensor, ulong scalar, DenseTensor<ulong> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ulong)(tensorSpan[i] ^ scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ulong)(tensorSpan[op1Index] ^ scalar);
-
-                }
-            }
-        }
-    }
-    internal class UShortArithmetic : ITensorArithmetic<ushort>
-    {
-        public ushort One => 1;
-        public ushort Zero => 0;
-
-        public void Add(Tensor<ushort> left, Tensor<ushort> right, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(left[indices] + right[indices]);
-            }
-
-        }
-        public void Add(Tensor<ushort> tensor, ushort scalar, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(tensor[indices] + scalar);
-            }
-
-        }
-        public void And(Tensor<ushort> left, Tensor<ushort> right, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(left[indices] & right[indices]);
-            }
-
-        }
-        public void And(Tensor<ushort> tensor, ushort scalar, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(tensor[indices] & scalar);
-            }
-
-        }
-        public void Contract(Tensor<ushort> left, Tensor<ushort> right, int[] leftAxes, int[] rightAxes, Tensor<ushort> result)
-        {
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                ushort sum = (ushort)0;
-
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (ushort)(left[leftIndices] * right[rightIndices]);
-                }
-
-                result[resultIndices] = sum;
-            }
-        }
-        public void Decrement(Tensor<ushort> tensor, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]--;
-            }
-
-        }
-        public void Divide(Tensor<ushort> left, Tensor<ushort> right, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(left[indices] / right[indices]);
-            }
-
-        }
-        public void Divide(Tensor<ushort> tensor, ushort scalar, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(tensor[indices] / scalar);
-            }
-
-        }
-        public void Equals(Tensor<ushort> left, Tensor<ushort> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] == right[indices];
-            }
-
-        }
-        public void GreaterThan(Tensor<ushort> left, Tensor<ushort> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] > right[indices];
-            }
-
-        }
-        public void GreaterThanOrEqual(Tensor<ushort> left, Tensor<ushort> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] >= right[indices];
-            }
-
-        }
-        public void Increment(Tensor<ushort> tensor, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices]++;
-            }
-
-        }
-        public void LeftShift(Tensor<ushort> tensor, int value, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(tensor[indices] << value);
-            }
-
-        }
-        public void LessThan(Tensor<ushort> left, Tensor<ushort> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] < right[indices];
-            }
-
-        }
-        public void LessThanOrEqual(Tensor<ushort> left, Tensor<ushort> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] <= right[indices];
-            }
-
-        }
-        public void Modulo(Tensor<ushort> left, Tensor<ushort> right, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(left[indices] % right[indices]);
-            }
-
-        }
-        public void Modulo(Tensor<ushort> tensor, ushort scalar, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(tensor[indices] % scalar);
-            }
-
-        }
-        public void Multiply(Tensor<ushort> left, Tensor<ushort> right, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(left[indices] * right[indices]);
-            }
-
-        }
-        public void Multiply(Tensor<ushort> tensor, ushort scalar, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(tensor[indices] * scalar);
-            }
-
-        }
-        public void NotEquals(Tensor<ushort> left, Tensor<ushort> right, Tensor<bool> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = left[indices] != right[indices];
-            }
-
-        }
-        public void Or(Tensor<ushort> left, Tensor<ushort> right, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(left[indices] | right[indices]);
-            }
-
-        }
-        public void Or(Tensor<ushort> tensor, ushort scalar, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(tensor[indices] | scalar);
-            }
-
-        }
-        public void RightShift(Tensor<ushort> tensor, int value, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(tensor[indices] >> value);
-            }
-
-        }
-        public void Subtract(Tensor<ushort> left, Tensor<ushort> right, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(left[indices] - right[indices]);
-            }
-
-        }
-        public void Subtract(Tensor<ushort> tensor, ushort scalar, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(tensor[indices] - scalar);
-            }
-
-        }
-        public void UnaryMinus(Tensor<ushort> tensor, Tensor<ushort> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void UnaryPlus(Tensor<ushort> tensor, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)+tensor[indices];
-            }
-
-        }
-        public void Xor(Tensor<ushort> left, Tensor<ushort> right, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(left[indices] ^ right[indices]);
-            }
-
-        }
-        public void Xor(Tensor<ushort> tensor, ushort scalar, Tensor<ushort> result)
-        {
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for (int i = 0; i < result.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                result[indices] = (ushort)(tensor[indices] ^ scalar);
-            }
-
-        }
-
-        public void Add(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(leftSpan[i] + rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(leftSpan[op1Index] + rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Add(DenseTensor<ushort> tensor, ushort scalar, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(tensorSpan[i] + scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(tensorSpan[op1Index] + scalar);
-
-                }
-            }
-        }
-        public void And(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(leftSpan[i] & rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(leftSpan[op1Index] & rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void And(DenseTensor<ushort> tensor, ushort scalar, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(tensorSpan[i] & scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(tensorSpan[op1Index] & scalar);
-
-                }
-            }
-        }
-        public void Contract(DenseTensor<ushort> left, DenseTensor<ushort> right, int[] leftAxes, int[] rightAxes, DenseTensor<ushort> result)
-        {
-            var summingDimensions = new int[leftAxes.Length];
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                ushort sum = (ushort)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (ushort)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-        }
-        public void Decrement(DenseTensor<ushort> tensor, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]--;
-            }
-        }
-        public void Divide(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(leftSpan[i] / rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(leftSpan[op1Index] / rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Divide(DenseTensor<ushort> tensor, ushort scalar, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(tensorSpan[i] / scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(tensorSpan[op1Index] / scalar);
-
-                }
-            }
-        }
-        public void Equals(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] == rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] == rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThan(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] > rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] > rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void GreaterThanOrEqual(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] >= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] >= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Increment(DenseTensor<ushort> tensor, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            for (int i = 0; i < resultSpan.Length; i++)
-            {
-                resultSpan[i]++;
-            }
-        }
-        public void LeftShift(DenseTensor<ushort> tensor, int value, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(tensorSpan[i] << value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(tensorSpan[op1Index] << value);
-
-                }
-            }
-        }
-        public void LessThan(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] < rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] < rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void LessThanOrEqual(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] <= rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] <= rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(leftSpan[i] % rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(leftSpan[op1Index] % rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Modulo(DenseTensor<ushort> tensor, ushort scalar, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(tensorSpan[i] % scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(tensorSpan[op1Index] % scalar);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(leftSpan[i] * rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(leftSpan[op1Index] * rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Multiply(DenseTensor<ushort> tensor, ushort scalar, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(tensorSpan[i] * scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(tensorSpan[op1Index] * scalar);
-
-                }
-            }
-        }
-        public void NotEquals(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<bool> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = leftSpan[i] != rightSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = leftSpan[op1Index] != rightSpan[op2Index];
-
-                }
-            }
-        }
-        public void Or(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(leftSpan[i] | rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(leftSpan[op1Index] | rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Or(DenseTensor<ushort> tensor, ushort scalar, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(tensorSpan[i] | scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(tensorSpan[op1Index] | scalar);
-
-                }
-            }
-        }
-        public void RightShift(DenseTensor<ushort> tensor, int value, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(tensorSpan[i] >> value);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(tensorSpan[op1Index] >> value);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(leftSpan[i] - rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(leftSpan[op1Index] - rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Subtract(DenseTensor<ushort> tensor, ushort scalar, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(tensorSpan[i] - scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(tensorSpan[op1Index] - scalar);
-
-                }
-            }
-        }
-        public void UnaryMinus(DenseTensor<ushort> tensor, DenseTensor<ushort> result)
-        {
-            throw new NotSupportedException();
-        }
-        public void UnaryPlus(DenseTensor<ushort> tensor, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)+tensorSpan[i];
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)+tensorSpan[op1Index];
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<ushort> left, DenseTensor<ushort> right, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-            if  ((result.IsReversedStride == left.IsReversedStride) && (result.IsReversedStride == right.IsReversedStride))
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(leftSpan[i] ^ rightSpan[i]);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref left.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                ref int op2Index = ref right.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      !left.IsReversedStride ? left.strides :
-                                      right.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         left.IsReversedStride ? left.strides :
-                                         right.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(leftSpan[op1Index] ^ rightSpan[op2Index]);
-
-                }
-            }
-        }
-        public void Xor(DenseTensor<ushort> tensor, ushort scalar, DenseTensor<ushort> result)
-        {
-
-            var resultSpan = result.Buffer.Span;
-            var tensorSpan = tensor.Buffer.Span;
-            if  (result.IsReversedStride == tensor.IsReversedStride)
-            {
-                for (int i = 0; i < resultSpan.Length; i++)
-                {
-                    resultSpan[i] = (ushort)(tensorSpan[i] ^ scalar);
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-
-                ref int resultIndex = ref result.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref tensor.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !result.IsReversedStride ? result.strides :
-                                      tensor.strides;
-                var columnMajorStrides = result.IsReversedStride ? result.strides :
-                                         tensor.strides;
-                for (;rowMajorIndex < resultSpan.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-
-                    resultSpan[resultIndex] = (ushort)(tensorSpan[op1Index] ^ scalar);
-
-                }
-            }
-        }
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorArithmetic.tt b/src/libraries/System.Numerics.Tensors/tests/TensorArithmetic.tt
deleted file mode 100644
index 91efa47c1ab768..00000000000000
--- a/src/libraries/System.Numerics.Tensors/tests/TensorArithmetic.tt
+++ /dev/null
@@ -1,237 +0,0 @@
-<#@ template debug="false" hostspecific="false" language="C#" #>
-<#@ assembly name="System.Core" #>
-<#@ output extension=".cs" #>
-<#@ include file="TensorTemplate.ttinclude" #>// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Numerics.Tensors
-{
-    internal interface ITensorArithmetic<T>
-    {
-        T One { get; }
-        T Zero { get; }
-<# foreach (MethodConfiguration method in methodConfiguration) { #>
-        <#= method.GetResultMethodSignature("Tensor", "T")#>;
-<# } #>
-    }
-
-    internal static class TensorArithmetic<T>
-    {
-        public static ITensorArithmetic<T> Instance => TensorArithmetic.GetArithmetic<T>();
-    }
-
-    internal static class TensorArithmetic
-    { 
-        public static ITensorArithmetic<T> GetArithmetic<T>()
-        {
-<# foreach (TypeConfiguration type in typeConfiguration) { #>
-            <#=GenerateIfStatementHeader(type)#>
-            {
-                return (ITensorArithmetic<T>)new <#=type.ClassPrefix#>Arithmetic();
-            }
-<# } #>
-            return null;
-        }
-    }
-    
-<# foreach (TypeConfiguration type in typeConfiguration) { #>
-    internal class <#=type.ClassPrefix#>Arithmetic : ITensorArithmetic<<#=type.TypeName#>>
-    {
-        public <#=type.TypeName#> One => <#=type.OneLiteral#>;
-        public <#=type.TypeName#> Zero => <#=type.ZeroLiteral#>;
-
-<# foreach (MethodConfiguration method in methodConfiguration) { #>
-        public <#= method.GetResultMethodSignature("Tensor", type.TypeName)#>
-        {
-<# if ((method.IsNumeric && !type.SupportsNumeric) ||  (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #>
-            throw new NotSupportedException();
-<# } else if (method.Operator != null) { #>
-
-            Span<int> indices = new Span<int>(new int[result.Rank]);
-            for(int i = 0; i < <#= method.ResultName #>.Length; i++)
-            {
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, i, indices);
-                <#=method.GetElementOperation(type.TypeName, "[indices]")#>;
-            }
-            
-<# } else if (method.MethodName == "Contract") {#>
-            var leftIndices = new int[left.Rank];
-            var rightIndices = new int[right.Rank];
-            var resultIndices = new int[result.Rank];
-
-            var summingDimensions = new int[leftAxes.Length];
-            for(int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-
-            for (int resultIndex = 0; resultIndex < result.Length; resultIndex++)
-            {
-                <#=type.TypeName#> sum = (<#=type.TypeName#>)0;
-                
-                ArrayUtilities.GetIndices(result.strides, result.IsReversedStride, resultIndex, resultIndices);
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    // todo, make this more efficient
-                    ArrayUtilities.GetIndices(left.strides, left.IsReversedStride, leftIndex, leftIndices);
-                    ArrayUtilities.GetIndices(right.strides, right.IsReversedStride, rightIndex, rightIndices);
-
-                    sum += (<#=type.TypeName#>)(left[leftIndices] * right[rightIndices]);
-                }
-                
-                result[resultIndices] = sum;
-            }
-<# } #>
-        }
-<# } #>
-
-<# foreach (MethodConfiguration method in methodConfiguration) { #>
-        public <#= method.GetResultMethodSignature("DenseTensor", type.TypeName)#>
-        {
-<# if ((method.IsNumeric && !type.SupportsNumeric) ||  (method.IsBitwise && !type.SupportsBitwise) || (type.UnsupportedMethods.Contains(method.MethodName))) { #>
-            throw new NotSupportedException();
-<# } else if (method.Operator != null) { #>
-
-<# if (method.MethodType == MethodType.UnaryInPlace) { #>
-            var <#=method.ResultName #>Span = <#=method.ResultName #>.Buffer.Span;
-            var <#=method.Op1Name #>Span = <#=method.Op1Name #>.Buffer.Span;
-            for(int i = 0; i < <#=method.ResultName #>Span.Length; i++)
-            {
-                <#=method.GetElementOperation(type.TypeName, "Span[i]")#>;
-            }
-<# } else {#>
-            var <#=method.ResultName #>Span = <#=method.ResultName #>.Buffer.Span;
-            var <#=method.Op1Name #>Span = <#=method.Op1Name #>.Buffer.Span;
-<# if ((method.MethodType == MethodType.Binary) || (method.MethodType == MethodType.Comparison)) {#>
-            var <#=method.Op2Name #>Span = <#=method.Op2Name #>.Buffer.Span;
-<# } #>
-            if  <#= method.GetLinearOperationCheck() #>
-            {
-                for(int i = 0; i < <#= method.ResultName #>Span.Length; i++)
-                {
-                    <#=method.GetElementOperation(type.TypeName, "Span[i]")#>;
-                }
-            }
-            else
-            {
-                int rowMajorIndex = 0;
-                int colMajorIndex = 0;
-                
-                ref int resultIndex = ref <#= method.ResultName #>.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                ref int op1Index = ref <#= method.Op1Name #>.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-                
-<# if ((method.MethodType == MethodType.Binary) || (method.MethodType == MethodType.Comparison)) {#>
-                ref int op2Index = ref <#= method.Op2Name #>.IsReversedStride ? ref colMajorIndex : ref rowMajorIndex;
-
-                var rowMajorStrides = !<#= method.ResultName #>.IsReversedStride ? <#= method.ResultName #>.strides :
-                                      !<#= method.Op1Name #>.IsReversedStride ? <#= method.Op1Name #>.strides : 
-                                      <#= method.Op2Name #>.strides;
-                var columnMajorStrides = <#= method.ResultName #>.IsReversedStride ? <#= method.ResultName #>.strides :
-                                         <#= method.Op1Name #>.IsReversedStride ? <#= method.Op1Name #>.strides : 
-                                         <#= method.Op2Name #>.strides;
-<# } else {#>
-                var rowMajorStrides = !<#= method.ResultName #>.IsReversedStride ? <#= method.ResultName #>.strides :
-                                      <#= method.Op1Name #>.strides;
-                var columnMajorStrides = <#= method.ResultName #>.IsReversedStride ? <#= method.ResultName #>.strides :
-                                         <#= method.Op1Name #>.strides;
-<# } #>
-                for(;rowMajorIndex < <#= method.ResultName #>Span.Length; rowMajorIndex++)
-                {
-                    colMajorIndex = ArrayUtilities.TransformIndexByStrides(rowMajorIndex, rowMajorStrides, false, columnMajorStrides);
-                    
-                    <#=method.GetElementOperation(type.TypeName, "Span[resultIndex]", "Span[op1Index]", "Span[op2Index]")#>;
-
-                }
-            }
-<# } #>
-<# } else if (method.MethodName == "Contract") {#>
-            var summingDimensions = new int[leftAxes.Length];
-            for(int i = 0; i < leftAxes.Length; i++)
-            {
-                summingDimensions[i] = left.dimensions[leftAxes[i]];
-            }
-
-            var summingStrides = ArrayUtilities.GetStrides(summingDimensions);
-            int summingLength = (int)ArrayUtilities.GetProduct(summingDimensions);
-
-            var resultStrides = result.strides;
-
-            // translates from result index to left non-summing dimensions' index portion
-            // since left non-summing dimensions are given precedence in result, the end is zero-padded
-            int[] leftNonSummingStrides = new int[result.Rank];
-
-            // translates from summing index to left summing dimensions' index portion
-            int[] leftSummingStrides = new int[leftAxes.Length];
-            ArrayUtilities.SplitStrides(left.strides, leftAxes, leftNonSummingStrides, 0, leftSummingStrides, 0);
-
-            // translates from result index to right non-summing dimensions' index portion
-            int[] rightNonSummingStrides = new int[result.Rank];
-            //  right non-summing dimensions appear after left non-summing dimensions.
-            int rightNonSummingStridesOffset = (left.Rank - leftAxes.Length);
-
-            // translates from summing index to right summing dimensions' index portion
-            int[] rightSummingStrides = new int[rightAxes.Length];
-            ArrayUtilities.SplitStrides(right.strides, rightAxes, rightNonSummingStrides, rightNonSummingStridesOffset, rightSummingStrides, 0);
-            
-            var resultSpan = result.Buffer.Span;
-            var leftSpan = left.Buffer.Span;
-            var rightSpan = right.Buffer.Span;
-
-            for (int resultIndex = 0; resultIndex < resultSpan.Length; resultIndex++)
-            {
-                <#=type.TypeName#> sum = (<#=type.TypeName#>)0;
-
-                int leftIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, leftNonSummingStrides);
-                int rightIndexNonSumming = ArrayUtilities.TransformIndexByStrides(resultIndex, resultStrides, result.IsReversedStride, rightNonSummingStrides);
-
-                for (int summingIndex = 0; summingIndex < summingLength; summingIndex++)
-                {
-                    int leftIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, leftSummingStrides);
-                    int rightIndexSumming = ArrayUtilities.TransformIndexByStrides(summingIndex, summingStrides, false, rightSummingStrides);
-
-                    int leftIndex = leftIndexNonSumming + leftIndexSumming;
-                    int rightIndex = rightIndexNonSumming + rightIndexSumming;
-
-                    sum += (<#=type.TypeName#>)(leftSpan[leftIndex] * rightSpan[rightIndex]);
-                }
-
-                resultSpan[resultIndex] = sum;
-            }
-<# } #>
-        }
-<# } #>
-    }
-<# } #>
-}
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorExtensions.cs b/src/libraries/System.Numerics.Tensors/tests/TensorExtensions.cs
deleted file mode 100644
index 2aa79f0e120589..00000000000000
--- a/src/libraries/System.Numerics.Tensors/tests/TensorExtensions.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Numerics.Tensors
-{
-    public static partial class TensorExtensions
-    {
-        private static int[] s_zeroArray = new[] { 0 };
-        private static int[] s_oneArray = new[] { 1 };
-
-        internal static Tensor<T> MatrixMultiply<T>(this Tensor<T> left, Tensor<T> right)
-        {
-            if (left.Rank != 2)
-            {
-                throw new InvalidOperationException($"{nameof(MatrixMultiply)} is only valid for a {nameof(Tensor<T>)} of {nameof(left.Rank)} 2.");
-            }
-
-            if (right.Rank != 2)
-            {
-                throw new ArgumentException($"{nameof(Tensor<T>)} {nameof(right)} must have {nameof(left.Rank)} 2.", nameof(right));
-            }
-
-            if (left.dimensions[1] != right.dimensions[0])
-            {
-                throw new ArgumentException($"{nameof(Tensor<T>)} {nameof(right)} must have first dimension of {left.dimensions[1]}.", nameof(right));
-            }
-
-            return TensorOperations.Contract(left, right, s_oneArray, s_zeroArray);
-        }
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorOperations.cs b/src/libraries/System.Numerics.Tensors/tests/TensorOperations.cs
deleted file mode 100644
index 009ad006b88c53..00000000000000
--- a/src/libraries/System.Numerics.Tensors/tests/TensorOperations.cs
+++ /dev/null
@@ -1,738 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Numerics.Tensors
-{
-    public static partial class TensorOperations
-    {
-        internal static void ValidateBinaryArgs<T>(Tensor<T> left, Tensor<T> right)
-        {
-            if (left.Rank != right.Rank || left.Length != right.Length)
-            {
-                throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-            }
-
-            if (left.Rank == 0)
-            {
-                throw new ArgumentException($"Cannot operate on Tensor with {nameof(Tensor<T>.Rank)} of 0.", nameof(left));
-            }
-
-            for (int i = 0; i < left.Rank; i++)
-            {
-                if (left.dimensions[i] != right.dimensions[i])
-                {
-                    throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-                }
-            }
-        }
-
-        internal static void ValidateBinaryArgs<T>(Tensor<T> left, Tensor<T> right, Tensor<T> result)
-        {
-            if (left.Rank != right.Rank || left.Length != right.Length)
-            {
-                throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-            }
-
-            if (left.Rank != result.Rank || left.Length != result.Length)
-            {
-                throw new ArgumentException("Operands must have matching dimensions", nameof(result));
-            }
-
-            if (left.Rank == 0)
-            {
-                throw new ArgumentException($"Cannot operate on Tensor with {nameof(Tensor<T>.Rank)} of 0.", nameof(left));
-            }
-
-            for (int i = 0; i < result.Rank; i++)
-            {
-                if (left.dimensions[i] != right.dimensions[i])
-                {
-                    throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-                }
-
-                if (left.dimensions[i] != result.dimensions[i])
-                {
-                    throw new ArgumentException("Operands and result must have matching dimensions", nameof(result));
-                }
-            }
-        }
-
-        internal static void ValidateBinaryArgs<T>(Tensor<T> left, Tensor<T> right, Tensor<bool> result)
-        {
-            if (left.Rank != right.Rank || left.Length != right.Length)
-            {
-                throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-            }
-
-            if (left.Rank != result.Rank || left.Length != result.Length)
-            {
-                throw new ArgumentException("Operands must have matching dimensions", nameof(result));
-            }
-
-            if (left.Rank == 0)
-            {
-                throw new ArgumentException($"Cannot operate on Tensor with {nameof(Tensor<T>.Rank)} of 0.", nameof(left));
-            }
-
-            for (int i = 0; i < result.Rank; i++)
-            {
-                if (left.dimensions[i] != right.dimensions[i])
-                {
-                    throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-                }
-
-                if (left.dimensions[i] != result.dimensions[i])
-                {
-                    throw new ArgumentException("Operands and result must have matching dimensions", nameof(result));
-                }
-            }
-        }
-
-        internal static void ValidateArgs<T>(Tensor<T> tensor)
-        {
-            if (tensor.Rank == 0)
-            {
-                throw new ArgumentException($"Cannot operate on Tensor with {nameof(Tensor<T>.Rank)} of 0.", nameof(tensor));
-            }
-        }
-
-        internal static void ValidateArgs<T>(Tensor<T> tensor, Tensor<T> result)
-        {
-            if (tensor.Rank != result.Rank || tensor.Length != result.Length)
-            {
-                throw new ArgumentException("Operands and result must have matching dimensions", nameof(result));
-            }
-
-            if (tensor.Rank == 0)
-            {
-                throw new ArgumentException($"Cannot operate on Tensor with {nameof(Tensor<T>.Rank)} of 0.", nameof(tensor));
-            }
-
-            for (int i = 0; i < result.Rank; i++)
-            {
-                if (tensor.dimensions[i] != result.dimensions[i])
-                {
-                    throw new ArgumentException("Operands and result must have matching dimensions", nameof(result));
-                }
-            }
-        }
-
-        internal static int[] ValidateContractArgs<T>(Tensor<T> left, Tensor<T> right, int[] leftAxes, int[] rightAxes)
-        {
-            if (leftAxes == null)
-            {
-                throw new ArgumentNullException(nameof(left));
-            }
-
-            if (rightAxes == null)
-            {
-                throw new ArgumentNullException(nameof(left));
-            }
-
-            if (leftAxes.Length != rightAxes.Length)
-            {
-                throw new ArgumentException($"{nameof(leftAxes)} and {nameof(rightAxes)} must have the same length, but were {leftAxes.Length} and {rightAxes.Length}, respectively.");
-            }
-
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                var leftAxis = leftAxes[i];
-
-                if (leftAxis >= left.Rank)
-                {
-                    throw new ArgumentOutOfRangeException($"{nameof(leftAxes)}[{i}] was set to axis index {leftAxis} which exceeds the Rank of {left}.");
-                }
-
-                var leftDimension = left.dimensions[leftAxis];
-
-                var rightAxis = rightAxes[i];
-
-                if (rightAxis >= right.Rank)
-                {
-                    throw new ArgumentOutOfRangeException($"{nameof(rightAxes)}[{i}] was set to axis index {rightAxis} which exceeds the Rank of {right}.");
-                }
-
-                var rightDimension = right.dimensions[rightAxis];
-
-                if (leftDimension != rightDimension)
-                {
-                    throw new ArgumentOutOfRangeException($"Tensors may only be contracted on axes of the same length, but {nameof(leftAxes)} index {i} was length {leftDimension} and {nameof(rightAxes)} index {i} was length {rightDimension}.");
-                }
-            }
-
-            var leftNonSummingDimensions = left.Rank - leftAxes.Length;
-            var rightNonSummingDimensions = right.Rank - rightAxes.Length;
-            var resultDimensions = new int[leftNonSummingDimensions + rightNonSummingDimensions];
-            int dimensionsIndex = 0;
-
-            Action<Tensor<T>, int[]> fillDimensions = (tensor, axes) =>
-            {
-                for (int i = 0; i < tensor.Rank; i++)
-                {
-                    var skip = false;
-                    foreach (var contractionIndex in axes)
-                    {
-                        if (contractionIndex == i)
-                        {
-                            skip = true;
-                            break;
-                        }
-                    }
-
-                    if (!skip)
-                    {
-                        resultDimensions[dimensionsIndex++] = tensor.dimensions[i];
-                    }
-                }
-            };
-
-            fillDimensions(left, leftAxes);
-            fillDimensions(right, rightAxes);
-
-            return resultDimensions;
-        }
-
-        internal static int[] ValidateContractArgs<T>(Tensor<T> left, Tensor<T> right, int[] leftAxes, int[] rightAxes, Tensor<T> result)
-        {
-            var expectedDimensions = ValidateContractArgs(left, right, leftAxes, rightAxes);
-
-            if (result.Rank != expectedDimensions.Length)
-            {
-                throw new ArgumentException($"{nameof(result)} should have {expectedDimensions.Length} dimensions but had {result.Rank}.");
-            }
-
-            for (int i = 0; i < expectedDimensions.Length; i++)
-            {
-                if (result.dimensions[i] != expectedDimensions[i])
-                {
-                    throw new ArgumentException($"{nameof(result)} dimension {i} should be {expectedDimensions[i]} but was {result.dimensions[i]}.");
-                }
-            }
-
-            return expectedDimensions;
-        }
-
-        internal static void Add<T>(Tensor<T> left, Tensor<T> right, Tensor<T> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.Add(left, right, result);
-        }
-
-        internal static Tensor<T> Add<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Add(left, right, result);
-
-            return result;
-        }
-
-        internal static void Add<T>(Tensor<T> tensor, T scalar, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.Add(tensor, scalar, result);
-        }
-
-        internal static Tensor<T> Add<T>(Tensor<T> tensor, T scalar)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Add(tensor, scalar, result);
-
-            return result;
-        }
-
-        internal static void And<T>(Tensor<T> left, Tensor<T> right, Tensor<T> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.And(left, right, result);
-        }
-
-        internal static Tensor<T> And<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.And(left, right, result);
-
-            return result;
-        }
-
-        internal static void And<T>(Tensor<T> tensor, T scalar, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.And(tensor, scalar, result);
-        }
-
-        internal static Tensor<T> And<T>(Tensor<T> tensor, T scalar)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.And(tensor, scalar, result);
-
-            return result;
-        }
-
-        internal static void Contract<T>(Tensor<T> left, Tensor<T> right, int[] leftAxes, int[] rightAxes, Tensor<T> result)
-        {
-            ValidateContractArgs(left, right, leftAxes, rightAxes, result);
-
-            TensorArithmetic<T>.Instance.Contract(left, right, leftAxes, rightAxes, result);
-        }
-
-        internal static Tensor<T> Contract<T>(Tensor<T> left, Tensor<T> right, int[] leftAxes, int[] rightAxes)
-        {
-            var resultDimensions = ValidateContractArgs(left, right, leftAxes, rightAxes);
-
-            var result = left.CloneEmpty(resultDimensions);
-
-            TensorArithmetic<T>.Instance.Contract(left, right, leftAxes, rightAxes, result);
-
-            return result;
-        }
-
-        internal static void Decrement<T>(Tensor<T> tensor, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.Decrement(tensor, result);
-        }
-
-        internal static Tensor<T> Decrement<T>(Tensor<T> tensor)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.Clone();
-
-            TensorArithmetic<T>.Instance.Decrement(tensor, result);
-
-            return result;
-        }
-
-        internal static void Divide<T>(Tensor<T> left, Tensor<T> right, Tensor<T> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.Divide(left, right, result);
-        }
-
-        internal static Tensor<T> Divide<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Divide(left, right, result);
-
-            return result;
-        }
-
-        internal static void Divide<T>(Tensor<T> tensor, T scalar, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.Divide(tensor, scalar, result);
-        }
-
-        internal static Tensor<T> Divide<T>(Tensor<T> tensor, T scalar)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Divide(tensor, scalar, result);
-
-            return result;
-        }
-
-        internal static void Equals<T>(Tensor<T> left, Tensor<T> right, Tensor<bool> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.Equals(left, right, result);
-        }
-
-        internal static Tensor<bool> Equals<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty<bool>();
-
-            TensorArithmetic<T>.Instance.Equals(left, right, result);
-
-            return result;
-        }
-
-        internal static void GreaterThan<T>(Tensor<T> left, Tensor<T> right, Tensor<bool> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.GreaterThan(left, right, result);
-        }
-
-        internal static Tensor<bool> GreaterThan<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty<bool>();
-
-            TensorArithmetic<T>.Instance.GreaterThan(left, right, result);
-
-            return result;
-        }
-
-        internal static void GreaterThanOrEqual<T>(Tensor<T> left, Tensor<T> right, Tensor<bool> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.GreaterThanOrEqual(left, right, result);
-        }
-
-        internal static Tensor<bool> GreaterThanOrEqual<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty<bool>();
-
-            TensorArithmetic<T>.Instance.GreaterThanOrEqual(left, right, result);
-
-            return result;
-        }
-
-        internal static void Increment<T>(Tensor<T> tensor, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.Increment(tensor, result);
-        }
-
-        internal static Tensor<T> Increment<T>(Tensor<T> tensor)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.Clone();
-
-            TensorArithmetic<T>.Instance.Increment(tensor, result);
-
-            return result;
-        }
-
-        internal static void LeftShift<T>(Tensor<T> tensor, int value, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.LeftShift(tensor, value, result);
-        }
-
-        internal static Tensor<T> LeftShift<T>(Tensor<T> tensor, int value)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.LeftShift(tensor, value, result);
-
-            return result;
-        }
-
-        internal static void LessThan<T>(Tensor<T> left, Tensor<T> right, Tensor<bool> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.LessThan(left, right, result);
-        }
-
-        internal static Tensor<bool> LessThan<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty<bool>();
-
-            TensorArithmetic<T>.Instance.LessThan(left, right, result);
-
-            return result;
-        }
-
-        internal static void LessThanOrEqual<T>(Tensor<T> left, Tensor<T> right, Tensor<bool> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.LessThanOrEqual(left, right, result);
-        }
-
-        internal static Tensor<bool> LessThanOrEqual<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty<bool>();
-
-            TensorArithmetic<T>.Instance.LessThanOrEqual(left, right, result);
-
-            return result;
-        }
-
-        internal static void Modulo<T>(Tensor<T> left, Tensor<T> right, Tensor<T> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.Modulo(left, right, result);
-        }
-
-        internal static Tensor<T> Modulo<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Modulo(left, right, result);
-
-            return result;
-        }
-
-        internal static void Modulo<T>(Tensor<T> tensor, T scalar, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.Modulo(tensor, scalar, result);
-        }
-
-        internal static Tensor<T> Modulo<T>(Tensor<T> tensor, T scalar)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Modulo(tensor, scalar, result);
-
-            return result;
-        }
-
-        internal static void Multiply<T>(Tensor<T> left, Tensor<T> right, Tensor<T> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.Multiply(left, right, result);
-        }
-
-        internal static Tensor<T> Multiply<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Multiply(left, right, result);
-
-            return result;
-        }
-
-        internal static void Multiply<T>(Tensor<T> tensor, T scalar, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.Multiply(tensor, scalar, result);
-        }
-
-        internal static Tensor<T> Multiply<T>(Tensor<T> tensor, T scalar)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Multiply(tensor, scalar, result);
-
-            return result;
-        }
-
-        internal static void NotEquals<T>(Tensor<T> left, Tensor<T> right, Tensor<bool> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.NotEquals(left, right, result);
-        }
-
-        internal static Tensor<bool> NotEquals<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty<bool>();
-
-            TensorArithmetic<T>.Instance.NotEquals(left, right, result);
-
-            return result;
-        }
-
-        internal static void Or<T>(Tensor<T> left, Tensor<T> right, Tensor<T> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.Or(left, right, result);
-        }
-
-        internal static Tensor<T> Or<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Or(left, right, result);
-
-            return result;
-        }
-
-        internal static void Or<T>(Tensor<T> tensor, T scalar, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.Or(tensor, scalar, result);
-        }
-
-        internal static Tensor<T> Or<T>(Tensor<T> tensor, T scalar)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Or(tensor, scalar, result);
-
-            return result;
-        }
-
-        internal static void RightShift<T>(Tensor<T> tensor, int value, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.RightShift(tensor, value, result);
-        }
-
-        internal static Tensor<T> RightShift<T>(Tensor<T> tensor, int value)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.RightShift(tensor, value, result);
-
-            return result;
-        }
-
-        internal static void Subtract<T>(Tensor<T> left, Tensor<T> right, Tensor<T> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.Subtract(left, right, result);
-        }
-
-        internal static Tensor<T> Subtract<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Subtract(left, right, result);
-
-            return result;
-        }
-
-        internal static void Subtract<T>(Tensor<T> tensor, T scalar, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.Subtract(tensor, scalar, result);
-        }
-
-        internal static Tensor<T> Subtract<T>(Tensor<T> tensor, T scalar)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Subtract(tensor, scalar, result);
-
-            return result;
-        }
-
-        internal static void UnaryMinus<T>(Tensor<T> tensor, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.UnaryMinus(tensor, result);
-        }
-
-        internal static Tensor<T> UnaryMinus<T>(Tensor<T> tensor)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.UnaryMinus(tensor, result);
-
-            return result;
-        }
-
-        internal static void UnaryPlus<T>(Tensor<T> tensor, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.UnaryPlus(tensor, result);
-        }
-
-        internal static Tensor<T> UnaryPlus<T>(Tensor<T> tensor)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.UnaryPlus(tensor, result);
-
-            return result;
-        }
-
-        internal static void Xor<T>(Tensor<T> left, Tensor<T> right, Tensor<T> result)
-        {
-            ValidateBinaryArgs(left, right, result);
-
-            TensorArithmetic<T>.Instance.Xor(left, right, result);
-        }
-
-        internal static Tensor<T> Xor<T>(Tensor<T> left, Tensor<T> right)
-        {
-            ValidateBinaryArgs(left, right);
-
-            var result = left.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Xor(left, right, result);
-
-            return result;
-        }
-
-        internal static void Xor<T>(Tensor<T> tensor, T scalar, Tensor<T> result)
-        {
-            ValidateArgs(tensor, result);
-
-            TensorArithmetic<T>.Instance.Xor(tensor, scalar, result);
-        }
-
-        internal static Tensor<T> Xor<T>(Tensor<T> tensor, T scalar)
-        {
-            ValidateArgs(tensor);
-
-            var result = tensor.CloneEmpty();
-
-            TensorArithmetic<T>.Instance.Xor(tensor, scalar, result);
-
-            return result;
-        }
-
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorOperations.tt b/src/libraries/System.Numerics.Tensors/tests/TensorOperations.tt
deleted file mode 100644
index 6b96c0bb554a5a..00000000000000
--- a/src/libraries/System.Numerics.Tensors/tests/TensorOperations.tt
+++ /dev/null
@@ -1,239 +0,0 @@
-<#@ template debug="false" hostspecific="false" language="C#" #>
-<#@ assembly name="System.Core" #>
-<#@ output extension=".cs" #>
-<#@ include file="TensorTemplate.ttinclude" #>// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace System.Numerics.Tensors
-{
-    public static partial class TensorOperations
-    {
-        internal static void ValidateBinaryArgs<T>(Tensor<T> left, Tensor<T> right)
-        {
-            if (left.Rank != right.Rank || left.Length != right.Length)
-            {
-                throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-            }
-
-            if (left.Rank == 0)
-            {
-                throw new ArgumentException($"Cannot operate on Tensor with {nameof(Tensor<T>.Rank)} of 0.", nameof(left));
-            }
-
-            for (int i = 0; i < left.Rank; i++)
-            {
-                if (left.dimensions[i] != right.dimensions[i])
-                {
-                    throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-                }
-            }
-        }
-
-        internal static void ValidateBinaryArgs<T>(Tensor<T> left, Tensor<T> right, Tensor<T> result)
-        {
-            if (left.Rank != right.Rank || left.Length != right.Length)
-            {
-                throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-            }
-
-            if (left.Rank != result.Rank || left.Length != result.Length)
-            {
-                throw new ArgumentException("Operands must have matching dimensions", nameof(result));
-            }
-
-            if (left.Rank == 0)
-            {
-                throw new ArgumentException($"Cannot operate on Tensor with {nameof(Tensor<T>.Rank)} of 0.", nameof(left));
-            }
-
-            for (int i = 0; i < result.Rank; i++)
-            {
-                if (left.dimensions[i] != right.dimensions[i])
-                {
-                    throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-                }
-
-                if (left.dimensions[i] != result.dimensions[i])
-                {
-                    throw new ArgumentException("Operands and result must have matching dimensions", nameof(result));
-                }
-            }
-        }
-
-        internal static void ValidateBinaryArgs<T>(Tensor<T> left, Tensor<T> right, Tensor<bool> result)
-        {
-            if (left.Rank != right.Rank || left.Length != right.Length)
-            {
-                throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-            }
-
-            if (left.Rank != result.Rank || left.Length != result.Length)
-            {
-                throw new ArgumentException("Operands must have matching dimensions", nameof(result));
-            }
-
-            if (left.Rank == 0)
-            {
-                throw new ArgumentException($"Cannot operate on Tensor with {nameof(Tensor<T>.Rank)} of 0.", nameof(left));
-            }
-
-            for (int i = 0; i < result.Rank; i++)
-            {
-                if (left.dimensions[i] != right.dimensions[i])
-                {
-                    throw new ArgumentException("Operands must have matching dimensions", nameof(right));
-                }
-
-                if (left.dimensions[i] != result.dimensions[i])
-                {
-                    throw new ArgumentException("Operands and result must have matching dimensions", nameof(result));
-                }
-            }
-        }
-
-        internal static void ValidateArgs<T>(Tensor<T> tensor)
-        {
-            if (tensor.Rank == 0)
-            {
-                throw new ArgumentException($"Cannot operate on Tensor with {nameof(Tensor<T>.Rank)} of 0.", nameof(tensor));
-            }
-        }
-
-        internal static void ValidateArgs<T>(Tensor<T> tensor, Tensor<T> result)
-        {
-            if (tensor.Rank != result.Rank || tensor.Length != result.Length)
-            {
-                throw new ArgumentException("Operands and result must have matching dimensions", nameof(result));
-            }
-
-            if (tensor.Rank == 0)
-            {
-                throw new ArgumentException($"Cannot operate on Tensor with {nameof(Tensor<T>.Rank)} of 0.", nameof(tensor));
-            }
-
-            for (int i = 0; i < result.Rank; i++)
-            {
-                if (tensor.dimensions[i] != result.dimensions[i])
-                {
-                    throw new ArgumentException("Operands and result must have matching dimensions", nameof(result));
-                }
-            }
-        }
-
-        internal static int[] ValidateContractArgs<T>(Tensor<T> left, Tensor<T> right, int[] leftAxes, int[] rightAxes)
-        {
-            if (leftAxes == null)
-            {
-                throw new ArgumentNullException(nameof(left));
-            }
-
-            if (rightAxes == null)
-            {
-                throw new ArgumentNullException(nameof(left));
-            }
-
-            if (leftAxes.Length != rightAxes.Length)
-            {
-                throw new ArgumentException($"{nameof(leftAxes)} and {nameof(rightAxes)} must have the same length, but were {leftAxes.Length} and {rightAxes.Length}, respectively.");
-            }
-
-            for (int i = 0; i < leftAxes.Length; i++)
-            {
-                var leftAxis = leftAxes[i];
-
-                if (leftAxis >= left.Rank)
-                {
-                    throw new ArgumentOutOfRangeException($"{nameof(leftAxes)}[{i}] was set to axis index {leftAxis} which exceeds the Rank of {left}.");
-                }
-
-                var leftDimension = left.dimensions[leftAxis];
-
-                var rightAxis = rightAxes[i];
-
-                if (rightAxis >= right.Rank)
-                {
-                    throw new ArgumentOutOfRangeException($"{nameof(rightAxes)}[{i}] was set to axis index {rightAxis} which exceeds the Rank of {right}.");
-                }
-
-                var rightDimension = right.dimensions[rightAxis];
-
-                if (leftDimension != rightDimension)
-                {
-                    throw new ArgumentOutOfRangeException($"Tensors may only be contracted on axes of the same length, but {nameof(leftAxes)} index {i} was length {leftDimension} and {nameof(rightAxes)} index {i} was length {rightDimension}.");
-                }
-            }
-
-            var leftNonSummingDimensions = left.Rank - leftAxes.Length;
-            var rightNonSummingDimensions = right.Rank - rightAxes.Length;
-            var resultDimensions = new int[leftNonSummingDimensions + rightNonSummingDimensions];
-            int dimensionsIndex = 0;
-
-            Action<Tensor<T>, int[]> fillDimensions = (tensor, axes) =>
-            {
-                for (int i = 0; i < tensor.Rank; i++)
-                {
-                    var skip = false;
-                    foreach (var contractionIndex in axes)
-                    {
-                        if (contractionIndex == i)
-                        {
-                            skip = true;
-                            break;
-                        }
-                    }
-
-                    if (!skip)
-                    {
-                        resultDimensions[dimensionsIndex++] = tensor.dimensions[i];
-                    }
-                }
-            };
-
-            fillDimensions(left, leftAxes);
-            fillDimensions(right, rightAxes);
-
-            return resultDimensions;
-        }
-
-        internal static int[] ValidateContractArgs<T>(Tensor<T> left, Tensor<T> right, int[] leftAxes, int[] rightAxes, Tensor<T> result)
-        {
-            var expectedDimensions = ValidateContractArgs(left, right, leftAxes, rightAxes);
-
-            if (result.Rank != expectedDimensions.Length)
-            {
-                throw new ArgumentException($"{nameof(result)} should have {expectedDimensions.Length} dimensions but had {result.Rank}.");
-            }
-
-            for (int i = 0; i < expectedDimensions.Length; i++)
-            {
-                if (result.dimensions[i] != expectedDimensions[i])
-                {
-                    throw new ArgumentException($"{nameof(result)} dimension {i} should be {expectedDimensions[i]} but was {result.dimensions[i]}.");
-                }
-            }
-
-            return expectedDimensions;
-        }
-
-<# foreach (MethodConfiguration method in methodConfiguration) { #>
-        internal static <#= method.GetGenericResultMethodSignature("Tensor", "T")#>
-        {
-            <#= method.GetValidationMethod(true) #>
-
-            TensorArithmetic<T>.Instance.<#=method.MethodName#>(<#=method.GetCallArguments()#>, <#= method.ResultName #>);
-        }
-
-        internal static <#= method.GetGenericMethodSignature("Tensor", "T")#>
-        {
-            <#= method.GetValidationMethod(false) #>
-
-            var <#= method.ResultName #> = <#=method.InitializeResult("T")#>;
-            
-            TensorArithmetic<T>.Instance.<#=method.MethodName#>(<#=method.GetCallArguments()#>, <#= method.ResultName #>);
-
-            return <#= method.ResultName #>;
-        }
-
-<# } #>
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
new file mode 100644
index 00000000000000..1e751543831c3c
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs
@@ -0,0 +1,633 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Xunit;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+#pragma warning disable xUnit1025 // reporting duplicate test cases due to not distinguishing 0.0 from -0.0
+
+namespace System.Numerics.Tensors.Tests
+{
+    public static class TensorPrimitivesTests
+    {
+        private const int TensorSize = 512;
+
+        private const int MismatchedTensorSize = 2;
+
+        private static readonly Random s_random = new Random(20230828);
+
+        private static float[] CreateTensor(int size)
+        {
+            return new float[size];
+        }
+
+        private static float[] CreateAndFillTensor(int size)
+        {
+            float[] tensor = CreateTensor(size);
+            FillTensor(tensor);
+            return tensor;
+        }
+
+        private static void FillTensor(float[] tensor)
+        {
+            for (int i = 0; i < tensor.Length; i++)
+            {
+                tensor[i] = NextSingle();
+            }
+        }
+
+        private static float NextSingle()
+        {
+#if NETCOREAPP
+            return s_random.NextSingle();
+#else
+            return (float)s_random.NextDouble();
+#endif
+        }
+
+        [Fact]
+        public static void AddTwoTensors()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Add(x, y, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] + y[i]), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void AddTwoTensors_ThrowsForMismatchedLengths()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(MismatchedTensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Add(x, y, destination));
+        }
+
+        [Fact]
+        public static void AddTwoTensors_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Add(x, y, destination));
+        }
+
+        [Fact]
+        public static void AddTensorAndScalar()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Add(x, y, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] + y), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void AddTensorAndScalar_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Add(x, y, destination));
+        }
+
+        [Fact]
+        public static void SubtractTwoTensors()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Subtract(x, y, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] - y[i]), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void SubtractTwoTensors_ThrowsForMismatchedLengths()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(MismatchedTensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Subtract(x, y, destination));
+        }
+
+        [Fact]
+        public static void SubtractTwoTensors_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Subtract(x, y, destination));
+        }
+
+        [Fact]
+        public static void SubtractTensorAndScalar()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Subtract(x, y, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] - y), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void SubtractTensorAndScalar_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Subtract(x, y, destination));
+        }
+
+        [Fact]
+        public static void MultiplyTwoTensors()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Multiply(x, y, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] * y[i]), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void MultiplyTwoTensors_ThrowsForMismatchedLengths()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(MismatchedTensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Multiply(x, y, destination));
+        }
+
+        [Fact]
+        public static void MultiplyTwoTensors_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Multiply(x, y, destination));
+        }
+
+        [Fact]
+        public static void MultiplyTensorAndScalar()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Multiply(x, y, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] * y), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void MultiplyTensorAndScalar_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Multiply(x, y, destination));
+        }
+
+        [Fact]
+        public static void DivideTwoTensors()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Divide(x, y, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] / y[i]), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void DivideTwoTensors_ThrowsForMismatchedLengths()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(MismatchedTensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Divide(x, y, destination));
+        }
+
+        [Fact]
+        public static void DivideTwoTensors_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Divide(x, y, destination));
+        }
+
+        [Fact]
+        public static void DivideTensorAndScalar()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Divide(x, y, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] / y), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void DivideTensorAndScalar_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Divide(x, y, destination));
+        }
+
+        [Fact]
+        public static void NegateTensor()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Negate(x, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal(-x[i], destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void NegateTensor_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Negate(x, destination));
+        }
+
+        [Fact]
+        public static void AddTwoTensorsAndMultiplyWithThirdTensor()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] multiplier = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.AddMultiply(x, y, multiplier, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] + y[i]) * multiplier[i], destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void AddTwoTensorsAndMultiplyWithThirdTensor_ThrowsForMismatchedLengths_x_y()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(MismatchedTensorSize);
+            float[] multiplier = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(x, y, multiplier, destination));
+        }
+
+        [Fact]
+        public static void AddTwoTensorsAndMultiplyWithThirdTensor_ThrowsForMismatchedLengths_x_multiplier()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] multiplier = CreateAndFillTensor(MismatchedTensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(x, y, multiplier, destination));
+        }
+
+        [Fact]
+        public static void AddTwoTensorsAndMultiplyWithThirdTensor_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] multiplier = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(x, y, multiplier, destination));
+        }
+
+        [Fact]
+        public static void AddTwoTensorsAndMultiplyWithScalar()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float multiplier = NextSingle();
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.AddMultiply(x, y, multiplier, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] + y[i]) * multiplier, destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void AddTwoTensorsAndMultiplyWithScalar_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float multiplier = NextSingle();
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(x, y, multiplier, destination));
+        }
+
+        [Fact]
+        public static void AddTensorAndScalarAndMultiplyWithTensor()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] multiplier = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.AddMultiply(x, y, multiplier, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] + y) * multiplier[i], destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void AddTensorAndScalarAndMultiplyWithTensor_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] multiplier = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.AddMultiply(x, y, multiplier, destination));
+        }
+
+        [Fact]
+        public static void MultiplyTwoTensorsAndAddWithThirdTensor()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] addend = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.MultiplyAdd(x, y, addend, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] * y[i]) + addend[i], destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void MultiplyTwoTensorsAndAddWithThirdTensor_ThrowsForMismatchedLengths_x_y()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(MismatchedTensorSize);
+            float[] addend = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.MultiplyAdd(x, y, addend, destination));
+        }
+
+        [Fact]
+        public static void MultiplyTwoTensorsAndAddWithThirdTensor_ThrowsForMismatchedLengths_x_multiplier()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] addend = CreateAndFillTensor(MismatchedTensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.MultiplyAdd(x, y, addend, destination));
+        }
+
+        [Fact]
+        public static void MultiplyTwoTensorsAndAddWithThirdTensor_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float[] addend = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.MultiplyAdd(x, y, addend, destination));
+        }
+
+        [Fact]
+        public static void MultiplyTwoTensorsAndAddWithScalar()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float addend = NextSingle();
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.MultiplyAdd(x, y, addend, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] * y[i]) + addend, destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void MultiplyTwoTensorsAndAddWithScalar_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] y = CreateAndFillTensor(TensorSize);
+            float addend = NextSingle();
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.MultiplyAdd(x, y, addend, destination));
+        }
+
+        [Fact]
+        public static void MultiplyTensorAndScalarAndAddWithTensor()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] addend = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.MultiplyAdd(x, y, addend, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal((x[i] * y) + addend[i], destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void MultiplyTensorAndScalarAndAddWithTensor_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float y = NextSingle();
+            float[] addend = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.MultiplyAdd(x, y, addend, destination));
+        }
+
+        [Fact]
+        public static void ExpTensor()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Exp(x, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal(MathF.Exp(x[i]), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void ExpTensor_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Exp(x, destination));
+        }
+
+        [Fact]
+        public static void LogTensor()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Log(x, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal(MathF.Log(x[i]), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void LogTensor_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Log(x, destination));
+        }
+
+        [Fact]
+        public static void CoshTensor()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Cosh(x, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal(MathF.Cosh(x[i]), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void CoshTensor_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Cosh(x, destination));
+        }
+
+        [Fact]
+        public static void SinhTensor()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Sinh(x, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal(MathF.Sinh(x[i]), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void SinhTensor_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Sinh(x, destination));
+        }
+
+        [Fact]
+        public static void TanhTensor()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(TensorSize);
+
+            TensorPrimitives.Tanh(x, destination);
+
+            for (int i = 0; i < TensorSize; i++)
+            {
+                Assert.Equal(MathF.Tanh(x[i]), destination[i]);
+            }
+        }
+
+        [Fact]
+        public static void TanhTensor_ThrowsForTooShortDestination()
+        {
+            float[] x = CreateAndFillTensor(TensorSize);
+            float[] destination = CreateTensor(MismatchedTensorSize);
+
+            Assert.Throws<ArgumentException>(() => TensorPrimitives.Tanh(x, destination));
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorTemplate.ttinclude b/src/libraries/System.Numerics.Tensors/tests/TensorTemplate.ttinclude
deleted file mode 100644
index 9448791a5db6c4..00000000000000
--- a/src/libraries/System.Numerics.Tensors/tests/TensorTemplate.ttinclude
+++ /dev/null
@@ -1,328 +0,0 @@
-<#@ import namespace="System.Linq" #>
-<#@ import namespace="System.Text" #>
-<#@ import namespace="System.Collections.Generic" #>
-<#+
-    public class TypeConfiguration
-    {
-        public TypeConfiguration(string typeName, string classPrefix = null, string oneLiteral = "1", string zeroLiteral = "0", bool supportsNumeric = true, bool supportsBitwise = true, IEnumerable<string> unsupportedMethods = null)
-        {
-            TypeName = typeName;
-            ClassPrefix = classPrefix ?? char.ToUpper(typeName[0]) + typeName.Substring(1);
-            OneLiteral = oneLiteral;
-            ZeroLiteral = zeroLiteral;
-            SupportsNumeric = supportsNumeric;
-            SupportsBitwise = supportsBitwise;
-            UnsupportedMethods = new HashSet<string>(unsupportedMethods ?? Enumerable.Empty<string>());
-        }
-
-        public string TypeName { get; }
-        public string ClassPrefix { get; }
-        public string OneLiteral { get; }
-        public string ZeroLiteral { get; }
-        
-        public bool SupportsNumeric { get; }
-        public bool SupportsBitwise { get; }
-        public ISet<string> UnsupportedMethods { get; }
-    }
-
-    public string GenerateIfStatementHeader(TypeConfiguration type)
-    {
-        string keyword = (type == typeConfiguration[0]) ? "if" : "else if";
-        return $"{keyword} (typeof(T) == typeof({type.TypeName}))";
-    }
-
-    public TypeConfiguration[] typeConfiguration = new []
-    {
-        new TypeConfiguration("bool", oneLiteral:"true", zeroLiteral:"false", supportsNumeric: false, unsupportedMethods: new[] {"LeftShift", "RightShift"}),
-        new TypeConfiguration("byte"),
-        new TypeConfiguration("char", oneLiteral:"(char)1", zeroLiteral:"(char)0"),
-        new TypeConfiguration("decimal", supportsBitwise: false),
-        new TypeConfiguration("double", oneLiteral:"1.0", supportsBitwise: false),
-        new TypeConfiguration("float", oneLiteral:"1.0f", supportsBitwise: false),
-        new TypeConfiguration("int"),
-        new TypeConfiguration("long"),
-        new TypeConfiguration("sbyte", classPrefix:"SByte"),
-        new TypeConfiguration("short"),
-        new TypeConfiguration("uint", classPrefix:"UInt", unsupportedMethods: new[] {"UnaryMinus"}),
-        new TypeConfiguration("ulong", classPrefix:"ULong", unsupportedMethods: new[] {"UnaryMinus"}),
-        new TypeConfiguration("ushort", classPrefix:"UShort", unsupportedMethods: new[] {"UnaryMinus"})
-    };
-
-    public enum MethodType
-    {
-       Unary,
-       UnaryInPlace,
-       BinaryScalar,
-       BinaryInt,
-       Binary,
-       Comparison,
-       Contraction
-    }
-
-    public class MethodConfiguration
-    {
-        public MethodConfiguration(string methodName, MethodType methodType, string op = null, bool isNumeric = false, bool isBitwise = false)
-        {
-            MethodName = methodName;
-            MethodType = methodType;
-            Operator = op;
-            IsNumeric = isNumeric;
-            IsBitwise = isBitwise;
-        }
-
-        public string ResultName => "result";
-        
-        public string Op1Name 
-        {
-            get
-            {
-                switch (MethodType)
-                {
-                    case MethodType.Unary:
-                    case MethodType.UnaryInPlace:
-                    case MethodType.BinaryScalar:
-                    case MethodType.BinaryInt:
-                        return "tensor";
-                    case MethodType.Binary:
-                    case MethodType.Comparison:
-                    case MethodType.Contraction:
-                        return "left";
-                    default:
-                        throw new ArgumentException();
-                };
-            }
-        }
-
-        public string Op2Name 
-        {
-            get
-            {
-                switch (MethodType)
-                {
-                    case MethodType.BinaryScalar:
-                        return "scalar";
-                    case MethodType.BinaryInt:
-                        return "value";
-                    case MethodType.Binary:
-                    case MethodType.Comparison:
-                    case MethodType.Contraction:
-                        return "right";
-                    case MethodType.Unary:
-                    case MethodType.UnaryInPlace:
-                    default:
-                        throw new ArgumentException();
-                };
-            }
-        }
-
-        public string MethodName { get; }
-        public MethodType MethodType { get; }
-        public string Operator { get; }
-        
-        public string GetGenericMethodSignature(string tensorType, string genericType)
-        {
-            var resultType = GetResultType(tensorType, genericType);
-            var arguments = GetMethodArguments(tensorType, genericType);
-
-            return $"{resultType} {MethodName}<{genericType}>({arguments})";
-        }
-        
-        public string GetGenericResultMethodSignature(string tensorType, string genericType)
-        {
-            var resultType = GetResultType(tensorType, genericType);
-            var arguments = GetMethodArguments(tensorType, genericType);
-
-            return $"void {MethodName}<{genericType}>({arguments}, {resultType} {ResultName})";
-        }
-
-        public string GetResultMethodSignature(string tensorType, string genericType)
-        {
-            var resultType = GetResultType(tensorType, genericType);
-            var arguments = GetMethodArguments(tensorType, genericType);
-
-            return $"void {MethodName}({arguments}, {resultType} {ResultName})";
-        }
-
-        public string GetMethodArguments(string tensorType, string genericType)
-        {
-            switch (MethodType)
-            {
-                case MethodType.Unary:
-                case MethodType.UnaryInPlace:
-                    return $"{tensorType}<{genericType}> {Op1Name}";
-                case MethodType.BinaryScalar:
-                    return $"{tensorType}<{genericType}> {Op1Name}, {genericType} {Op2Name}";
-                case MethodType.BinaryInt:
-                    return $"{tensorType}<{genericType}> {Op1Name}, int {Op2Name}";
-                case MethodType.Binary:
-                case MethodType.Comparison:
-                    return $"{tensorType}<{genericType}> {Op1Name}, {tensorType}<{genericType}> {Op2Name}";
-                case MethodType.Contraction:
-                    return $"{tensorType}<{genericType}> {Op1Name}, {tensorType}<{genericType}> {Op2Name}, int[] leftAxes, int[] rightAxes";
-                default:
-                    throw new ArgumentException();
-            }
-        }
-
-        public string GetCallArguments()
-        {
-            switch (MethodType)
-            {
-                case MethodType.Unary:
-                case MethodType.UnaryInPlace:
-                    return $"{Op1Name}";
-                case MethodType.BinaryScalar:
-                case MethodType.BinaryInt:
-                case MethodType.Binary:
-                case MethodType.Comparison:
-                    return $"{Op1Name}, {Op2Name}";
-                case MethodType.Contraction:
-                    return "left, right, leftAxes, rightAxes";
-                default:
-                    throw new ArgumentException();
-            }
-        }
-        
-        public string GetValidationMethod(bool includeResult)
-        {
-            var suffix = includeResult ? ", result" : "";
-            switch (MethodType)
-            {
-                case MethodType.Unary:
-                case MethodType.UnaryInPlace:
-                case MethodType.BinaryScalar:
-                case MethodType.BinaryInt:
-                    return $"ValidateArgs({Op1Name}{suffix});";
-                case MethodType.Binary:
-                case MethodType.Comparison:
-                    return $"ValidateBinaryArgs({Op1Name}, {Op2Name}{suffix});";
-                case MethodType.Contraction:
-                    return $"var resultDimensions = ValidateContractArgs({Op1Name}, {Op2Name}, leftAxes, rightAxes{suffix});";
-                default:
-                    throw new ArgumentException();
-            }
-        }
-
-        public string GetResultType(string tensorType, string typeName)
-        {
-            switch (MethodType)
-            {
-                case MethodType.Unary:
-                case MethodType.UnaryInPlace:
-                case MethodType.BinaryScalar:
-                case MethodType.BinaryInt:
-                case MethodType.Binary:
-                case MethodType.Contraction:
-                    return $"{tensorType}<{typeName}>";
-                case MethodType.Comparison:
-                    return $"{tensorType}<bool>";
-                default:
-                    throw new ArgumentException();
-            }
-        }
-
-        public string GetLinearOperationCheck()
-        {
-            switch (MethodType)
-            {
-                case MethodType.Unary:
-                case MethodType.BinaryScalar:
-                case MethodType.BinaryInt:
-                    return $"({ResultName}.IsReversedStride == {Op1Name}.IsReversedStride)";
-                case MethodType.Binary:
-                case MethodType.Comparison:
-                    return $"(({ResultName}.IsReversedStride == {Op1Name}.IsReversedStride) && ({ResultName}.IsReversedStride == {Op2Name}.IsReversedStride))";
-                case MethodType.UnaryInPlace:
-                default:
-                    throw new ArgumentException();
-            }
-        }
-
-
-        public string GetElementOperation(string typeName, string access)
-        {
-            return GetElementOperation(typeName, access, access, access);
-        }
-
-        public string GetElementOperation(string typeName, string resultAccess, string leftAccess, string rightAccess)
-        {
-            switch (MethodType)
-            {
-                case MethodType.Unary:
-                    return $"{ResultName}{resultAccess} = ({typeName}){Operator}{Op1Name}{leftAccess}";
-                case MethodType.UnaryInPlace:
-                    return $"{ResultName}{resultAccess}{Operator}";
-                case MethodType.BinaryScalar:
-                case MethodType.BinaryInt:
-                    return $"{ResultName}{resultAccess} = ({typeName})({Op1Name}{leftAccess} {Operator} {Op2Name})";
-                case MethodType.Binary:
-                    return $"{ResultName}{resultAccess} = ({typeName})({Op1Name}{leftAccess} {Operator} {Op2Name}{rightAccess})";
-                case MethodType.Comparison:
-                    return $"{ResultName}{resultAccess} = {Op1Name}{leftAccess} {Operator} {Op2Name}{rightAccess}";
-                default:
-                    throw new ArgumentException();
-
-            }
-        }
-
-        public string InitializeResult(string typeName)
-        {
-            switch (MethodType)
-            {
-                case MethodType.UnaryInPlace:
-                    return $"{Op1Name}.Clone()";
-                case MethodType.Unary:
-                case MethodType.BinaryScalar:
-                case MethodType.BinaryInt:
-                case MethodType.Binary:
-                    return $"{Op1Name}.CloneEmpty()";
-                case MethodType.Comparison:
-                    return $"{Op1Name}.CloneEmpty<bool>()";
-                case MethodType.Contraction:
-                    return $"{Op1Name}.CloneEmpty(resultDimensions)";
-                default:
-                    throw new ArgumentException();
-            }
-        }
-        
-        public bool IsNumeric { get; }
-        public bool IsBitwise { get; }
-    }
-
-    
-    public MethodConfiguration[] methodConfiguration = new []
-    {
-        new MethodConfiguration("Add", MethodType.Binary, "+", isNumeric:true),
-        new MethodConfiguration("Add", MethodType.BinaryScalar, "+", isNumeric:true),
-        new MethodConfiguration("UnaryPlus", MethodType.Unary, "+", isNumeric:true),
-        new MethodConfiguration("Subtract", MethodType.Binary, "-", isNumeric:true),
-        new MethodConfiguration("Subtract", MethodType.BinaryScalar, "-", isNumeric:true),
-        new MethodConfiguration("UnaryMinus", MethodType.Unary, "-", isNumeric:true),
-        new MethodConfiguration("Increment", MethodType.UnaryInPlace, "++", isNumeric:true),
-        new MethodConfiguration("Decrement", MethodType.UnaryInPlace, "--", isNumeric:true),
-        new MethodConfiguration("Multiply", MethodType.Binary, "*", isNumeric:true),  // element-wise product, not matrix product
-        new MethodConfiguration("Multiply", MethodType.BinaryScalar, "*", isNumeric:true),
-        new MethodConfiguration("Divide", MethodType.Binary, "/", isNumeric:true),
-        new MethodConfiguration("Divide", MethodType.BinaryScalar, "/", isNumeric:true),
-        new MethodConfiguration("Modulo", MethodType.Binary, "%", isNumeric:true),
-        new MethodConfiguration("Modulo", MethodType.BinaryScalar, "%", isNumeric:true),
-        new MethodConfiguration("And", MethodType.Binary, "&", isBitwise: true),
-        new MethodConfiguration("And", MethodType.BinaryScalar, "&", isBitwise: true),
-        new MethodConfiguration("Or", MethodType.Binary, "|", isBitwise: true),
-        new MethodConfiguration("Or", MethodType.BinaryScalar, "|", isBitwise: true),
-        new MethodConfiguration("Xor", MethodType.Binary, "^", isBitwise: true),
-        new MethodConfiguration("Xor", MethodType.BinaryScalar, "^", isBitwise: true),
-        new MethodConfiguration("LeftShift", MethodType.BinaryInt, "<<", isBitwise: true),
-        new MethodConfiguration("RightShift", MethodType.BinaryInt, ">>", isBitwise: true),
-
-        // Note all of these are element-wise operations not testing the operation on the entire Tensor
-        new MethodConfiguration("Equals", MethodType.Comparison, "=="),
-        new MethodConfiguration("NotEquals", MethodType.Comparison, "!="),
-        new MethodConfiguration("GreaterThanOrEqual", MethodType.Comparison, ">=", isNumeric:true),
-        new MethodConfiguration("LessThanOrEqual", MethodType.Comparison, "<=", isNumeric:true),
-        new MethodConfiguration("GreaterThan", MethodType.Comparison, ">", isNumeric:true),
-        new MethodConfiguration("LessThan", MethodType.Comparison, "<", isNumeric:true),
-
-        new MethodConfiguration("Contract", MethodType.Contraction, isNumeric:true),
-    }.OrderBy(m => m.MethodName).ToArray();
-#>
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
deleted file mode 100644
index 27c7ba75e4e259..00000000000000
--- a/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
+++ /dev/null
@@ -1,2486 +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.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using Xunit;
-
-namespace System.Numerics.Tensors.Tests
-{
-    public class TensorTests : TensorTestsBase
-    {
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void ConstructTensorFromArrayRank1(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromArray<int>(new[] { 0, 1, 2 });
-
-            Assert.Equal(tensorConstructor.IsReversedStride, tensor.IsReversedStride);
-            Assert.Equal(0, tensor[0]);
-            Assert.Equal(1, tensor[1]);
-            Assert.Equal(2, tensor[2]);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void ConstructTensorFromArrayRank2(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-                {0, 1, 2},
-                {3, 4, 5}
-            });
-
-            Assert.Equal(tensorConstructor.IsReversedStride, tensor.IsReversedStride);
-            Assert.Equal(0, tensor[0, 0]);
-            Assert.Equal(1, tensor[0, 1]);
-            Assert.Equal(2, tensor[0, 2]);
-            Assert.Equal(3, tensor[1, 0]);
-            Assert.Equal(4, tensor[1, 1]);
-            Assert.Equal(5, tensor[1, 2]);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void ConstructTensorFromArrayRank3(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromArray<int>(new[, ,]
-            {
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                },
-                {
-                    {6, 7 ,8 },
-                    {9, 10 ,11 },
-                },
-                {
-                    {12, 13 ,14 },
-                    {15, 16 ,17 },
-                },
-                {
-                    {18, 19 ,20 },
-                    {21, 22 ,23 },
-                }
-            });
-
-            Assert.Equal(tensorConstructor.IsReversedStride, tensor.IsReversedStride);
-
-            Assert.Equal(0, tensor[0, 0, 0]);
-            Assert.Equal(1, tensor[0, 0, 1]);
-            Assert.Equal(2, tensor[0, 0, 2]);
-            Assert.Equal(3, tensor[0, 1, 0]);
-            Assert.Equal(4, tensor[0, 1, 1]);
-            Assert.Equal(5, tensor[0, 1, 2]);
-
-            Assert.Equal(6, tensor[1, 0, 0]);
-            Assert.Equal(7, tensor[1, 0, 1]);
-            Assert.Equal(8, tensor[1, 0, 2]);
-            Assert.Equal(9, tensor[1, 1, 0]);
-            Assert.Equal(10, tensor[1, 1, 1]);
-            Assert.Equal(11, tensor[1, 1, 2]);
-
-            Assert.Equal(12, tensor[2, 0, 0]);
-            Assert.Equal(13, tensor[2, 0, 1]);
-            Assert.Equal(14, tensor[2, 0, 2]);
-            Assert.Equal(15, tensor[2, 1, 0]);
-            Assert.Equal(16, tensor[2, 1, 1]);
-            Assert.Equal(17, tensor[2, 1, 2]);
-
-            Assert.Equal(18, tensor[3, 0, 0]);
-            Assert.Equal(19, tensor[3, 0, 1]);
-            Assert.Equal(20, tensor[3, 0, 2]);
-            Assert.Equal(21, tensor[3, 1, 0]);
-            Assert.Equal(22, tensor[3, 1, 1]);
-            Assert.Equal(23, tensor[3, 1, 2]);
-        }
-
-        [Fact]
-        public void ConstructDenseTensorFromPointer()
-        {
-            using (var nativeMemory = NativeMemoryFromArray(Enumerable.Range(0, 24).ToArray()))
-            {
-                var dimensions = new[] { 4, 2, 3 };
-                var tensor = new DenseTensor<int>(nativeMemory.Memory, dimensions, false);
-
-                Assert.Equal(0, tensor[0, 0, 0]);
-                Assert.Equal(1, tensor[0, 0, 1]);
-                Assert.Equal(2, tensor[0, 0, 2]);
-                Assert.Equal(3, tensor[0, 1, 0]);
-                Assert.Equal(4, tensor[0, 1, 1]);
-                Assert.Equal(5, tensor[0, 1, 2]);
-
-                Assert.Equal(6, tensor[1, 0, 0]);
-                Assert.Equal(7, tensor[1, 0, 1]);
-                Assert.Equal(8, tensor[1, 0, 2]);
-                Assert.Equal(9, tensor[1, 1, 0]);
-                Assert.Equal(10, tensor[1, 1, 1]);
-                Assert.Equal(11, tensor[1, 1, 2]);
-
-                Assert.Equal(12, tensor[2, 0, 0]);
-                Assert.Equal(13, tensor[2, 0, 1]);
-                Assert.Equal(14, tensor[2, 0, 2]);
-                Assert.Equal(15, tensor[2, 1, 0]);
-                Assert.Equal(16, tensor[2, 1, 1]);
-                Assert.Equal(17, tensor[2, 1, 2]);
-
-                Assert.Equal(18, tensor[3, 0, 0]);
-                Assert.Equal(19, tensor[3, 0, 1]);
-                Assert.Equal(20, tensor[3, 0, 2]);
-                Assert.Equal(21, tensor[3, 1, 0]);
-                Assert.Equal(22, tensor[3, 1, 1]);
-                Assert.Equal(23, tensor[3, 1, 2]);
-            }
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void ConstructSparseTensor(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-                {0, 0, 0, 0},
-                {5, 8, 0, 0},
-                {0, 0, 3, 0},
-                {0, 6, 0, 0}
-            });
-
-            Assert.Equal(tensorConstructor.IsReversedStride, tensor.IsReversedStride);
-
-
-            Assert.Equal(0, tensor[0, 0]);
-            Assert.Equal(0, tensor[0, 1]);
-            Assert.Equal(0, tensor[0, 2]);
-            Assert.Equal(0, tensor[0, 3]);
-
-
-            Assert.Equal(5, tensor[1, 0]);
-            Assert.Equal(8, tensor[1, 1]);
-            Assert.Equal(0, tensor[1, 2]);
-            Assert.Equal(0, tensor[1, 3]);
-
-
-            Assert.Equal(0, tensor[2, 0]);
-            Assert.Equal(0, tensor[2, 1]);
-            Assert.Equal(3, tensor[2, 2]);
-            Assert.Equal(0, tensor[2, 3]);
-
-
-            Assert.Equal(0, tensor[3, 0]);
-            Assert.Equal(6, tensor[3, 1]);
-            Assert.Equal(0, tensor[3, 2]);
-            Assert.Equal(0, tensor[3, 3]);
-
-            if (tensorConstructor.TensorType == TensorType.CompressedSparse)
-            {
-                var compressedSparseTensor = (CompressedSparseTensor<int>)tensor;
-
-                Assert.Equal(4, compressedSparseTensor.NonZeroCount);
-
-                int[] expectedValues, expectedCompressedCounts, expectedIndices;
-
-                if (compressedSparseTensor.IsReversedStride)
-                {
-                    // csc
-                    expectedValues = new[] { 5, 8, 6, 3 };
-                    expectedCompressedCounts = new[] { 0, 1, 3, 4, 4 };
-                    expectedIndices = new[] { 1, 1, 3, 2 };
-                }
-                else
-                {
-                    // csr
-                    expectedValues = new[] { 5, 8, 3, 6 };
-                    expectedCompressedCounts = new[] { 0, 0, 2, 3, 4 };
-                    expectedIndices = new[] { 0, 1, 2, 1 };
-                }
-                Assert.Equal<int>(expectedValues, compressedSparseTensor.Values.Slice(0, compressedSparseTensor.NonZeroCount).ToArray());
-                Assert.Equal<int>(expectedCompressedCounts, compressedSparseTensor.CompressedCounts.ToArray());
-                Assert.Equal<int>(expectedIndices, compressedSparseTensor.Indices.Slice(0, compressedSparseTensor.NonZeroCount).ToArray());
-            }
-        }
-
-        [Theory()]
-        [InlineData(false)]
-        [InlineData(true)]
-        public void ConstructCompressedSparseTensorFromPointers(bool isReversedStride)
-        {
-            int[] values, compressedCounts, indices;
-            if (isReversedStride)
-            {
-                // csc
-                values = new[] { 5, 8, 6, 3 };
-                compressedCounts = new[] { 0, 1, 3, 4, 4 };
-                indices = new[] { 1, 1, 3, 2 };
-            }
-            else
-            {
-                // csr
-                values = new[] { 5, 8, 3, 6 };
-                compressedCounts = new[] { 0, 0, 2, 3, 4 };
-                indices = new[] { 0, 1, 2, 1 };
-            }
-            int[] dimensions = new[] { 4, 4 };
-
-            using (var valuesMemory = NativeMemoryFromArray(values))
-            using (var compressedCountsMemory = NativeMemoryFromArray(compressedCounts))
-            using (var indicesMemory = NativeMemoryFromArray(indices))
-            {
-                var tensor = new CompressedSparseTensor<int>(valuesMemory.Memory,
-                                                             compressedCountsMemory.Memory,
-                                                             indicesMemory.Memory,
-                                                             values.Length,
-                                                             dimensions,
-                                                             isReversedStride);
-
-                Assert.Equal(0, tensor[0, 0]);
-                Assert.Equal(0, tensor[0, 1]);
-                Assert.Equal(0, tensor[0, 2]);
-                Assert.Equal(0, tensor[0, 3]);
-
-
-                Assert.Equal(5, tensor[1, 0]);
-                Assert.Equal(8, tensor[1, 1]);
-                Assert.Equal(0, tensor[1, 2]);
-                Assert.Equal(0, tensor[1, 3]);
-
-
-                Assert.Equal(0, tensor[2, 0]);
-                Assert.Equal(0, tensor[2, 1]);
-                Assert.Equal(3, tensor[2, 2]);
-                Assert.Equal(0, tensor[2, 3]);
-
-
-                Assert.Equal(0, tensor[3, 0]);
-                Assert.Equal(6, tensor[3, 1]);
-                Assert.Equal(0, tensor[3, 2]);
-                Assert.Equal(0, tensor[3, 3]);
-            }
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void ConstructFromDimensions(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromDimensions<int>(new[] { 2, 3, 4 });
-            Assert.Equal(3, tensor.Rank);
-            Assert.Equal(3, tensor.Dimensions.Length);
-            Assert.Equal(2, tensor.Dimensions[0]);
-            Assert.Equal(3, tensor.Dimensions[1]);
-            Assert.Equal(4, tensor.Dimensions[2]);
-            Assert.Equal(24, tensor.Length);
-            Assert.Equal(tensorConstructor.IsReversedStride, tensor.IsReversedStride);
-
-            //Assert.Throws<ArgumentNullException>("dimensions", () => tensorConstructor.CreateFromDimensions<int>(dimensions: null));
-            Assert.Throws<ArgumentException>("dimensions", () => tensorConstructor.CreateFromDimensions<int>(dimensions: new int[0]));
-
-            Assert.Throws<ArgumentOutOfRangeException>("dimensions", () => tensorConstructor.CreateFromDimensions<int>(dimensions: new[] { 1, 0 }));
-            Assert.Throws<ArgumentOutOfRangeException>("dimensions", () => tensorConstructor.CreateFromDimensions<int>(dimensions: new[] { 1, -1 }));
-
-            // ensure dimensions are immutable
-            var dimensions = new[] { 1, 2, 3 };
-            tensor = tensorConstructor.CreateFromDimensions<int>(dimensions: dimensions);
-            dimensions[0] = dimensions[1] = dimensions[2] = 0;
-            Assert.Equal(1, tensor.Dimensions[0]);
-            Assert.Equal(2, tensor.Dimensions[1]);
-            Assert.Equal(3, tensor.Dimensions[2]);
-        }
-
-        [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNonZeroLowerBoundArraySupported))]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void ConstructTensorFromArrayRank3WithLowerBounds(TensorConstructor tensorConstructor)
-        {
-            var dimensions = new[] { 2, 3, 4 };
-            var lowerBounds = new[] { 0, 5, 200 };
-            var arrayWithLowerBounds = Array.CreateInstance(typeof(int), dimensions, lowerBounds);
-
-            int value = 0;
-            for (int x = lowerBounds[0]; x < lowerBounds[0] + dimensions[0]; x++)
-            {
-                for (int y = lowerBounds[1]; y < lowerBounds[1] + dimensions[1]; y++)
-                {
-                    for (int z = lowerBounds[2]; z < lowerBounds[2] + dimensions[2]; z++)
-                    {
-                        arrayWithLowerBounds.SetValue(value++, x, y, z);
-                    }
-                }
-            }
-
-            var tensor = tensorConstructor.CreateFromArray<int>(arrayWithLowerBounds);
-
-            var expected = tensorConstructor.CreateFromArray<int>(new[, ,]
-                    {
-                        {
-                            { 0, 1, 2, 3 },
-                            { 4, 5, 6, 7 },
-                            { 8, 9, 10, 11 }
-                        },
-                        {
-                            { 12, 13, 14, 15 },
-                            { 16, 17, 18, 19 },
-                            { 20, 21, 22, 23 }
-                        }
-                    }
-                );
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(expected, tensor));
-            Assert.Equal(tensorConstructor.IsReversedStride, tensor.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void StructurallyEqualTensor(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var arr = new[, ,]
-            {
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                },
-                {
-                    {6, 7 ,8 },
-                    {9, 10 ,11 },
-                },
-                {
-                    {12, 13 ,14 },
-                    {15, 16 ,17 },
-                },
-                {
-                    {18, 19 ,20 },
-                    {21, 22 ,23 },
-                }
-            };
-            var tensor = leftConstructor.CreateFromArray<int>(arr);
-            var tensor2 = rightConstructor.CreateFromArray<int>(arr);
-
-            Assert.Equal(0, StructuralComparisons.StructuralComparer.Compare(tensor, tensor2));
-            Assert.Equal(0, StructuralComparisons.StructuralComparer.Compare(tensor2, tensor));
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tensor, tensor2));
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tensor2, tensor));
-            // Issue: should Tensors with different layout be structurally equal?
-            if (leftConstructor.IsReversedStride == leftConstructor.IsReversedStride)
-            {
-                Assert.Equal(StructuralComparisons.StructuralEqualityComparer.GetHashCode(tensor), StructuralComparisons.StructuralEqualityComparer.GetHashCode(tensor2));
-            }
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void StructurallyEqualArray(TensorConstructor tensorConstructor)
-        {
-            var arr = new[, ,]
-            {
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                },
-                {
-                    {6, 7 ,8 },
-                    {9, 10 ,11 },
-                },
-                {
-                    {12, 13 ,14 },
-                    {15, 16 ,17 },
-                },
-                {
-                    {18, 19 ,20 },
-                    {21, 22 ,23 },
-                }
-            };
-            var tensor = tensorConstructor.CreateFromArray<int>(arr);
-
-            Assert.Equal(0, StructuralComparisons.StructuralComparer.Compare(tensor, arr));
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tensor, arr));
-
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void GetDiagonalSquare(TensorConstructor tensorConstructor)
-        {
-            var arr = new[,]
-            {
-               { 1, 2, 4 },
-               { 8, 3, 9 },
-               { 1, 7, 5 },
-            };
-
-            var tensor = tensorConstructor.CreateFromArray<int>(arr);
-            var diag = tensor.GetDiagonal();
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 1, 3, 5 }));
-            diag = tensor.GetDiagonal(1);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 2, 9 }));
-            diag = tensor.GetDiagonal(2);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 4 }));
-            Assert.Throws<ArgumentException>("offset", () => tensor.GetDiagonal(3));
-
-            diag = tensor.GetDiagonal(-1);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 8, 7 }));
-            diag = tensor.GetDiagonal(-2);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 1 }));
-            Assert.Throws<ArgumentException>("offset", () => tensor.GetDiagonal(-3));
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void GetDiagonalRectangle(TensorConstructor tensorConstructor)
-        {
-            var arr = new[,]
-            {
-               { 1, 2, 4, 3, 7 },
-               { 8, 3, 9, 2, 6 },
-               { 1, 7, 5, 2, 9 }
-            };
-
-            var tensor = tensorConstructor.CreateFromArray<int>(arr);
-            var diag = tensor.GetDiagonal();
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 1, 3, 5 }));
-            diag = tensor.GetDiagonal(1);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 2, 9, 2 }));
-            diag = tensor.GetDiagonal(2);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 4, 2, 9 }));
-            diag = tensor.GetDiagonal(3);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 3, 6 }));
-            diag = tensor.GetDiagonal(4);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 7 }));
-            Assert.Throws<ArgumentException>("offset", () => tensor.GetDiagonal(5));
-
-            diag = tensor.GetDiagonal(-1);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 8, 7 }));
-            diag = tensor.GetDiagonal(-2);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, new[] { 1 }));
-            Assert.Throws<ArgumentException>("offset", () => tensor.GetDiagonal(-3));
-            Assert.Throws<ArgumentException>("offset", () => tensor.GetDiagonal(-4));
-            Assert.Throws<ArgumentException>("offset", () => tensor.GetDiagonal(-5));
-        }
-
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void GetDiagonalCube(TensorConstructor tensorConstructor)
-        {
-            var arr = new[, ,]
-            {
-                {
-                   { 1, 2, 4 },
-                   { 8, 3, 9 },
-                   { 1, 7, 5 },
-                },
-                {
-                   { 4, 5, 7 },
-                   { 1, 6, 2 },
-                   { 3, 0, 8 },
-                },
-                {
-                   { 5, 6, 1 },
-                   { 2, 2, 3 },
-                   { 4, 9, 4 },
-                },
-
-            };
-
-            var tensor = tensorConstructor.CreateFromArray<int>(arr);
-            var diag = tensor.GetDiagonal();
-            var expected = new[,]
-            {
-                { 1, 2, 4 },
-                { 1, 6, 2 },
-                { 4, 9, 4 }
-            };
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(diag, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, diag.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void GetTriangleSquare(TensorConstructor tensorConstructor)
-        {
-            var arr = new[,]
-            {
-               { 1, 2, 4 },
-               { 8, 3, 9 },
-               { 1, 7, 5 },
-            };
-
-            var tensor = tensorConstructor.CreateFromArray<int>(arr);
-            var tri = tensor.GetTriangle(0);
-            Assert.Equal(tensorConstructor.IsReversedStride, tri.IsReversedStride);
-
-            var expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 0, 0 },
-               { 8, 3, 0 },
-               { 1, 7, 5 },
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetTriangle(1);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 2, 0 },
-               { 8, 3, 9 },
-               { 1, 7, 5 },
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetTriangle(2);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 2, 4 },
-               { 8, 3, 9 },
-               { 1, 7, 5 },
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetTriangle(3);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetTriangle(200);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetTriangle(-1);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 0 },
-               { 8, 0, 0 },
-               { 1, 7, 0 },
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetTriangle(-2);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 0 },
-               { 0, 0, 0 },
-               { 1, 0, 0 },
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 0 },
-               { 0, 0, 0 },
-               { 0, 0, 0 },
-            });
-            tri = tensor.GetTriangle(-3);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            // same as -3, should it be an exception?
-            tri = tensor.GetTriangle(-4);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetTriangle(-300);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void GetTriangleRectangle(TensorConstructor tensorConstructor)
-        {
-            var arr = new[,]
-            {
-               { 1, 2, 4, 3, 7 },
-               { 8, 3, 9, 2, 6 },
-               { 1, 7, 5, 2, 9 }
-            };
-
-            var tensor = tensorConstructor.CreateFromArray<int>(arr);
-            var tri = tensor.GetTriangle(0);
-            var expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 0, 0, 0, 0 },
-               { 8, 3, 0, 0, 0 },
-               { 1, 7, 5, 0, 0 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, tri.IsReversedStride);
-
-            tri = tensor.GetTriangle(1);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 2, 0, 0, 0 },
-               { 8, 3, 9, 0, 0 },
-               { 1, 7, 5, 2, 0 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetTriangle(2);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 2, 4, 0, 0 },
-               { 8, 3, 9, 2, 0 },
-               { 1, 7, 5, 2, 9 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetTriangle(3);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 2, 4, 3, 0 },
-               { 8, 3, 9, 2, 6 },
-               { 1, 7, 5, 2, 9 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetTriangle(4);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 2, 4, 3, 7 },
-               { 8, 3, 9, 2, 6 },
-               { 1, 7, 5, 2, 9 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            // same as 4, should it be an exception?
-            tri = tensor.GetTriangle(5);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetTriangle(1000);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetTriangle(-1);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 0, 0, 0 },
-               { 8, 0, 0, 0, 0 },
-               { 1, 7, 0, 0, 0 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 0, 0, 0 },
-               { 0, 0, 0, 0, 0 },
-               { 1, 0, 0, 0, 0 }
-            });
-            tri = tensor.GetTriangle(-2);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 0, 0, 0 },
-               { 0, 0, 0, 0, 0 },
-               { 0, 0, 0, 0, 0 }
-            });
-            tri = tensor.GetTriangle(-3);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetTriangle(-4);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetTriangle(-5);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetTriangle(-100);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void GetTriangleCube(TensorConstructor tensorConstructor)
-        {
-            var arr = new[, ,]
-            {
-                {
-                   { 1, 2, 4 },
-                   { 8, 3, 9 },
-                   { 1, 7, 5 },
-                },
-                {
-                   { 4, 5, 7 },
-                   { 1, 6, 2 },
-                   { 3, 0, 8 },
-                },
-                {
-                   { 5, 6, 1 },
-                   { 2, 2, 3 },
-                   { 4, 9, 4 },
-                },
-
-            };
-
-            var tensor = tensorConstructor.CreateFromArray<int>(arr);
-            var tri = tensor.GetTriangle(0);
-            var expected = tensorConstructor.CreateFromArray<int>(new[, ,]
-            {
-                {
-                   { 1, 2, 4 },
-                   { 0, 0, 0 },
-                   { 0, 0, 0 },
-                },
-                {
-                   { 4, 5, 7 },
-                   { 1, 6, 2 },
-                   { 0, 0, 0 },
-                },
-                {
-                   { 5, 6, 1 },
-                   { 2, 2, 3 },
-                   { 4, 9, 4 },
-                },
-
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, tri.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void GetUpperTriangleSquare(TensorConstructor tensorConstructor)
-        {
-            var arr = new[,]
-            {
-               { 1, 2, 4 },
-               { 8, 3, 9 },
-               { 1, 7, 5 },
-            };
-
-            var tensor = tensorConstructor.CreateFromArray<int>(arr);
-            var tri = tensor.GetUpperTriangle(0);
-
-            var expected = tensorConstructor.CreateFromArray<int>(new[,]
-             {
-               { 1, 2, 4 },
-               { 0, 3, 9 },
-               { 0, 0, 5 },
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, tri.IsReversedStride);
-
-            tri = tensor.GetUpperTriangle(1);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 2, 4 },
-               { 0, 0, 9 },
-               { 0, 0, 0 },
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetUpperTriangle(2);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 4 },
-               { 0, 0, 0 },
-               { 0, 0, 0 },
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetUpperTriangle(3);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 0 },
-               { 0, 0, 0 },
-               { 0, 0, 0 },
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetUpperTriangle(4);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetUpperTriangle(42);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetUpperTriangle(-1);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 2, 4 },
-               { 8, 3, 9 },
-               { 0, 7, 5 },
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetUpperTriangle(-2);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 2, 4 },
-               { 8, 3, 9 },
-               { 1, 7, 5 },
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetUpperTriangle(-3);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetUpperTriangle(-300);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void GetUpperTriangleRectangle(TensorConstructor tensorConstructor)
-        {
-            var arr = new[,]
-            {
-               { 1, 2, 4, 3, 7 },
-               { 8, 3, 9, 2, 6 },
-               { 1, 7, 5, 2, 9 }
-            };
-
-            var tensor = tensorConstructor.CreateFromArray<int>(arr);
-            var tri = tensor.GetUpperTriangle(0);
-            var expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 2, 4, 3, 7 },
-               { 0, 3, 9, 2, 6 },
-               { 0, 0, 5, 2, 9 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, tri.IsReversedStride);
-            tri = tensor.GetUpperTriangle(1);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 2, 4, 3, 7 },
-               { 0, 0, 9, 2, 6 },
-               { 0, 0, 0, 2, 9 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetUpperTriangle(2);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 4, 3, 7 },
-               { 0, 0, 0, 2, 6 },
-               { 0, 0, 0, 0, 9 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetUpperTriangle(3);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 0, 3, 7 },
-               { 0, 0, 0, 0, 6 },
-               { 0, 0, 0, 0, 0 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetUpperTriangle(4);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 0, 0, 7 },
-               { 0, 0, 0, 0, 0 },
-               { 0, 0, 0, 0, 0 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 0, 0, 0, 0, 0 },
-               { 0, 0, 0, 0, 0 },
-               { 0, 0, 0, 0, 0 }
-            });
-            tri = tensor.GetUpperTriangle(5);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetUpperTriangle(6);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetUpperTriangle(1000);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetUpperTriangle(-1);
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 2, 4, 3, 7 },
-               { 8, 3, 9, 2, 6 },
-               { 0, 7, 5, 2, 9 }
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            expected = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-               { 1, 2, 4, 3, 7 },
-               { 8, 3, 9, 2, 6 },
-               { 1, 7, 5, 2, 9 }
-            });
-            tri = tensor.GetUpperTriangle(-2);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-
-            tri = tensor.GetUpperTriangle(-3);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetUpperTriangle(-4);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            tri = tensor.GetUpperTriangle(-100);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void GetUpperTriangleCube(TensorConstructor tensorConstructor)
-        {
-            var arr = new[, ,]
-            {
-                {
-                   { 1, 2, 4 },
-                   { 8, 3, 9 },
-                   { 1, 7, 5 },
-                },
-                {
-                   { 4, 5, 7 },
-                   { 1, 6, 2 },
-                   { 3, 0, 8 },
-                },
-                {
-                   { 5, 6, 1 },
-                   { 2, 2, 3 },
-                   { 4, 9, 4 },
-                },
-
-            };
-
-            var tensor = tensorConstructor.CreateFromArray<int>(arr);
-            var tri = tensor.GetUpperTriangle(0);
-            var expected = tensorConstructor.CreateFromArray<int>(new[, ,]
-            {
-                {
-                   { 1, 2, 4 },
-                   { 8, 3, 9 },
-                   { 1, 7, 5 },
-                },
-                {
-                   { 0, 0, 0 },
-                   { 1, 6, 2 },
-                   { 3, 0, 8 },
-                },
-                {
-                   { 0, 0, 0 },
-                   { 0, 0, 0 },
-                   { 4, 9, 4 },
-                },
-
-            });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tri, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, tri.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void Reshape(TensorConstructor tensorConstructor)
-        {
-            var arr = new[,]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            };
-
-            var tensor = tensorConstructor.CreateFromArray<int>(arr);
-            var actual = tensor.Reshape(new[] { 3, 2 });
-
-            var expected = tensorConstructor.IsReversedStride ?
-                new[,]
-                {
-                    { 1, 5 },
-                    { 4, 3 },
-                    { 2, 6 }
-                } :
-                new[,]
-                {
-                    { 1, 2 },
-                    { 3, 4 },
-                    { 5, 6 }
-                };
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Fact]
-        public void Identity()
-        {
-            var actual = Tensor.CreateIdentity<double>(3);
-
-            var expected = new[,]
-            {
-                {1.0, 0, 0 },
-                {0, 1.0, 0 },
-                {0, 0, 1.0 }
-            };
-
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-        }
-
-        [Theory]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void CreateWithDiagonal(TensorConstructor tensorConstructor)
-        {
-            var diagonal = tensorConstructor.CreateFromArray<int>(new[] { 1, 2, 3, 4, 5 });
-            var actual = Tensor.CreateFromDiagonal(diagonal);
-
-            var expected = new[,]
-            {
-                {1, 0, 0, 0, 0 },
-                {0, 2, 0, 0, 0 },
-                {0, 0, 3, 0, 0 },
-                {0, 0, 0, 4, 0 },
-                {0, 0, 0, 0, 5 }
-            };
-
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-        }
-
-        [Theory]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void CreateWithDiagonal3D(TensorConstructor tensorConstructor)
-        {
-            var diagonal = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-                { 1, 2, 3, 4, 5 },
-                { 1, 2, 3, 4, 5 },
-                { 1, 2, 3, 4, 5 }
-            });
-            var actual = Tensor.CreateFromDiagonal(diagonal);
-            var expected = new[, ,]
-            {
-                {
-                    {1, 2, 3, 4, 5 },
-                    {0, 0, 0, 0, 0 },
-                    {0, 0, 0, 0, 0 }
-                },
-                {
-                    {0, 0, 0, 0, 0 },
-                    {1, 2, 3, 4, 5 },
-                    {0, 0, 0, 0, 0 }
-                },
-                {
-                    {0, 0, 0, 0, 0 },
-                    {0, 0, 0, 0, 0 },
-                    {1, 2, 3, 4, 5 }
-                }
-            };
-
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-        }
-
-        [Theory]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void CreateWithDiagonalAndOffset(TensorConstructor tensorConstructor)
-        {
-            var diagonal = tensorConstructor.CreateFromArray<int>(new[] { 1, 2, 3, 4 });
-            var actual = Tensor.CreateFromDiagonal(diagonal, 1);
-
-            var expected = new[,]
-            {
-                {0, 1, 0, 0, 0 },
-                {0, 0, 2, 0, 0 },
-                {0, 0, 0, 3, 0 },
-                {0, 0, 0, 0, 4 },
-                {0, 0, 0, 0, 0 }
-            };
-
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-
-            diagonal = tensorConstructor.CreateFromArray<int>(new[] { 1, 2, 3, 4 });
-            actual = Tensor.CreateFromDiagonal(diagonal, -1);
-
-            expected = new[,]
-            {
-                {0, 0, 0, 0, 0 },
-                {1, 0, 0, 0, 0 },
-                {0, 2, 0, 0, 0 },
-                {0, 0, 3, 0, 0 },
-                {0, 0, 0, 4, 0 }
-            };
-
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-
-            diagonal = tensorConstructor.CreateFromArray<int>(new[] { 1 });
-            actual = Tensor.CreateFromDiagonal(diagonal, -4);
-            expected = new[,]
-            {
-                {0, 0, 0, 0, 0 },
-                {0, 0, 0, 0, 0 },
-                {0, 0, 0, 0, 0 },
-                {0, 0, 0, 0, 0 },
-                {1, 0, 0, 0, 0 }
-            };
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-
-            diagonal = tensorConstructor.CreateFromArray<int>(new[] { 1 });
-            actual = Tensor.CreateFromDiagonal(diagonal, 4);
-            expected = new[,]
-            {
-                {0, 0, 0, 0, 1 },
-                {0, 0, 0, 0, 0 },
-                {0, 0, 0, 0, 0 },
-                {0, 0, 0, 0, 0 },
-                {0, 0, 0, 0, 0 }
-            };
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-        }
-
-        [Theory]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void CreateWithDiagonalAndOffset3D(TensorConstructor tensorConstructor)
-        {
-            var diagonal = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-                { 1, 2, 3 },
-                { 1, 2, 3 },
-                { 1, 2, 3 }
-            });
-            var actual = Tensor.CreateFromDiagonal(diagonal, 1);
-
-            var expected = new[, ,]
-            {
-                {
-                    { 0, 0, 0 },
-                    { 1, 2, 3 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 }
-                },
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 1, 2, 3 },
-                    { 0, 0, 0 }
-                },
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 1, 2, 3 }
-                },
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 }
-                }
-            };
-
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-
-            diagonal = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-                { 1, 2, 3 },
-                { 1, 2, 3 },
-                { 1, 2, 3 }
-            });
-            actual = Tensor.CreateFromDiagonal(diagonal, -1);
-
-            expected = new[, ,]
-            {
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 }
-                },
-                {
-                    { 1, 2, 3 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 }
-                },
-                {
-                    { 0, 0, 0 },
-                    { 1, 2, 3 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 }
-                },
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 1, 2, 3 },
-                    { 0, 0, 0 }
-                }
-            };
-
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-
-            diagonal = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-                { 1, 2, 3 }
-            });
-            actual = Tensor.CreateFromDiagonal(diagonal, 3);
-
-            expected = new[, ,]
-            {
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 1, 2, 3 },
-                },
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 }
-                },
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 }
-                },
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 }
-                }
-            };
-
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-
-            diagonal = tensorConstructor.CreateFromArray<int>(new[,]
-            {
-                { 1, 2, 3 }
-            });
-            actual = Tensor.CreateFromDiagonal(diagonal, -3);
-
-            expected = new[, ,]
-            {
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                },
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 }
-                },
-                {
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 }
-                },
-                {
-                    { 1, 2, 3 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 },
-                    { 0, 0, 0 }
-                }
-            };
-
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void Add(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-            var right = rightConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    { 6, 7 ,8 },
-                    { 9, 10 ,11 },
-                });
-
-            var expected = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    { 6, 8, 10 },
-                    { 12, 14, 16 },
-                });
-
-            var actual = TensorOperations.Add(left, right);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(leftConstructor.IsReversedStride, actual.IsReversedStride);
-
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void AddScalar(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expected = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    { 1, 2, 3 },
-                    { 4, 5, 6 },
-                });
-
-            var actual = TensorOperations.Add(tensor, 1);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void UnaryPlus(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expected = tensor;
-
-            var actual = TensorOperations.UnaryPlus(tensor);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.False(ReferenceEquals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-
-        [Theory()]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void Subtract(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-            var right = rightConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    { 6, 7 ,8 },
-                    { 9, 10 ,11 },
-                });
-
-            var expected = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    { -6, -6, -6 },
-                    { -6, -6, -6},
-                });
-
-            var actual = TensorOperations.Subtract(left, right);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(leftConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void SubtractScalar(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-            var expected = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    { -1, 0, 1 },
-                    { 2, 3, 4 },
-                });
-
-            var actual = TensorOperations.Subtract(tensor, 1);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void UnaryMinus(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expected = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, -1, -2},
-                    {-3, -4, -5}
-                });
-
-            var actual = TensorOperations.UnaryMinus(tensor);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.False(ReferenceEquals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void PrefixIncrement(TensorConstructor tensorConstructor)
-        {
-            Tensor<int> tensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expectedResult = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 2, 3},
-                    {4, 5, 6}
-                });
-
-            var expectedTensor = expectedResult;
-
-            tensor = TensorOperations.Increment(tensor);
-            var actual = tensor;
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expectedResult));
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tensor, expectedTensor));
-            Assert.True(ReferenceEquals(tensor, actual));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void PostfixIncrement(TensorConstructor tensorConstructor)
-        {
-            Tensor<int> tensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            // returns original value
-            var expectedResult = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            // increments operand
-            var expectedTensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 2, 3},
-                    {4, 5, 6}
-                });
-
-            var actual = tensor;
-            tensor = TensorOperations.Increment(tensor);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expectedResult));
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tensor, expectedTensor));
-            Assert.False(ReferenceEquals(tensor, actual));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void PrefixDecrement(TensorConstructor tensorConstructor)
-        {
-            Tensor<int> tensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expectedResult = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {-1, 0, 1},
-                    {2, 3, 4}
-                });
-
-            var expectedTensor = expectedResult;
-
-            tensor = TensorOperations.Decrement(tensor);
-            var actual = tensor;
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expectedResult));
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tensor, expectedTensor));
-            Assert.True(ReferenceEquals(tensor, actual));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void PostfixDecrement(TensorConstructor tensorConstructor)
-        {
-            Tensor<int> tensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            // returns original value
-            var expectedResult = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            // decrements operand
-            var expectedTensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {-1, 0, 1},
-                    {2, 3, 4}
-                });
-
-            var actual = tensor;
-            tensor = TensorOperations.Decrement(tensor);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expectedResult));
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(tensor, expectedTensor));
-            Assert.False(ReferenceEquals(tensor, actual));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void Multiply(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-            var right = rightConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expected = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 4},
-                    {9, 16, 25}
-                });
-
-            var actual = TensorOperations.Multiply(left, right);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(leftConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void MultiplyScalar(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expected = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 2, 4},
-                    {6, 8, 10}
-                });
-
-            var actual = TensorOperations.Multiply(tensor, 2);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void Divide(TensorConstructor dividendConstructor, TensorConstructor divisorConstructor)
-        {
-            var dividend = dividendConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 4},
-                    {9, 16, 25}
-                });
-
-            var divisor = divisorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expected = divisorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var actual = TensorOperations.Divide(dividend, divisor);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(dividendConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void DivideScalar(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 2, 4},
-                    {6, 8, 10}
-                });
-
-            var expected = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var actual = TensorOperations.Divide(tensor, 2);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void Modulo(TensorConstructor dividendConstructor, TensorConstructor divisorConstructor)
-        {
-            var dividend = dividendConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 3, 8},
-                    {11, 14, 17}
-                });
-
-            var divisor = divisorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 2, 3},
-                    {4, 5, 6}
-                });
-
-            var expected = dividendConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var actual = TensorOperations.Modulo(dividend, divisor);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(dividendConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void ModuloScalar(TensorConstructor tensorConstructor)
-        {
-            var tensor = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 3, 4},
-                    {7, 8, 9}
-                });
-
-            var expected = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 0},
-                    {1, 0, 1}
-                });
-
-            var actual = TensorOperations.Modulo(tensor, 2);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void And(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 3},
-                    {7, 15, 31}
-                });
-
-            var right = rightConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 1, 3},
-                    {2, 4, 8}
-                });
-
-            var expected = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 3},
-                    {2, 4, 8}
-                });
-
-            var actual = TensorOperations.And(left, right);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(leftConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void AndScalar(TensorConstructor tensorConstructor)
-        {
-            var left = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 3},
-                    {5, 15, 31}
-                });
-
-            var expected = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 0, 0},
-                    {4, 4, 20}
-                });
-
-            var actual = TensorOperations.And(left, 20);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void Or(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 3},
-                    {7, 14, 31}
-                });
-
-            var right = rightConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 2, 4},
-                    {2, 4, 8}
-                });
-
-            var expected = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 3, 7},
-                    {7, 14, 31}
-                });
-
-            var actual = TensorOperations.Or(left, right);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(leftConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void OrScalar(TensorConstructor tensorConstructor)
-        {
-            var left = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expected = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 1, 3},
-                    {3, 5, 5}
-                });
-
-            var actual = TensorOperations.Or(left, 1);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void Xor(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 3},
-                    {7, 14, 31}
-                });
-
-            var right = rightConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 2, 4},
-                    {2, 4, 8}
-                });
-
-            var expected = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 3, 7},
-                    {5, 10, 23}
-                });
-
-            var actual = TensorOperations.Xor(left, right);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(leftConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void XorScalar(TensorConstructor tensorConstructor)
-        {
-            var left = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expected = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 0, 3},
-                    {2, 5, 4}
-                });
-
-            var actual = TensorOperations.Xor(left, 1);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void LeftShift(TensorConstructor tensorConstructor)
-        {
-            var left = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expected = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 2, 4},
-                    {6, 8, 10}
-                });
-
-            var actual = TensorOperations.LeftShift(left, 1);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void RightShift(TensorConstructor tensorConstructor)
-        {
-            var left = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var expected = tensorConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 0, 1},
-                    {1, 2, 2}
-                });
-
-            var actual = TensorOperations.RightShift(left, 1);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(tensorConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void ElementWiseEquals(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-            var right = rightConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, -2},
-                    {2, 3, 5}
-                });
-
-            var expected = new[,]
-                {
-                    {true, true, false },
-                    {false, false, true}
-                }.ToTensor();
-
-            var actual = TensorOperations.Equals(left, right);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(leftConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory()]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void ElementWiseNotEquals(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-            var right = rightConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, -2},
-                    {2, 3, 5}
-                });
-
-            var expected = new[,]
-                {
-                    {false, false, true},
-                    {true, true, false}
-                }.ToTensor();
-
-            var actual = TensorOperations.NotEquals(left, right);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.Equal(leftConstructor.IsReversedStride, actual.IsReversedStride);
-        }
-
-        [Theory]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void MatrixMultiply(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2},
-                    {3, 4, 5}
-                });
-
-            var right = rightConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0, 1, 2, 3, 4},
-                    {5, 6, 7, 8, 9},
-                    {10, 11, 12, 13, 14}
-                });
-
-            var expected = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0*0 + 1*5 + 2*10, 0*1 + 1*6 + 2*11, 0*2 + 1*7 + 2*12, 0*3 + 1*8 + 2*13, 0*4 + 1*9 + 2*14},
-                    {3*0 + 4*5 + 5*10, 3*1 + 4*6 + 5*11, 3*2 + 4*7 + 5*12, 3*3 + 4*8 + 5*13, 3*4 + 4*9 + 5*14}
-                });
-
-            var actual = left.MatrixMultiply(right);
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-        }
-
-
-        [Theory]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void Contract(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[, ,]
-                {
-                    {
-                        {0, 1},
-                        {2, 3}
-                    },
-                    {
-                        {4, 5},
-                        {6, 7}
-                    },
-                    {
-                        {8, 9},
-                        {10, 11}
-                    }
-                });
-
-            var right = rightConstructor.CreateFromArray<int>(
-                new[, ,]
-                {
-                    {
-                        {0, 1},
-                        {2, 3},
-                        {4, 5}
-                    },
-                    {
-                        {6, 7},
-                        {8, 9},
-                        {10, 11}
-                    },
-                    {
-                        {12, 13},
-                        {14, 15},
-                        {16, 17}
-                    },
-                    {
-                        {18, 19},
-                        {20, 21},
-                        {22, 23}
-                    }
-                });
-
-            // contract a 3*2*2 with a 4*3*2 tensor, summing on (3*2)*2 and 4*(3*2) to produce a 2*4 tensor
-            var expected = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {110, 290, 470, 650},
-                    {125, 341, 557, 773},
-                });
-            var actual = TensorOperations.Contract(left, right, new[] { 0, 1 }, new[] { 1, 2 });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-
-            // contract a 3*2*2 with a 4*3*2 tensor, summing on (3)*2*(2) and 4*(3*2) to produce a 2*4 tensor
-            expected = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {101, 263, 425, 587},
-                    {131, 365, 599, 833},
-                });
-            actual = TensorOperations.Contract(left, right, new[] { 0, 2 }, new[] { 1, 2 });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-        }
-
-
-        [Theory]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void ContractWithSingleLengthDimension(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {1, 2, 3},
-                    {4, 5, 6},
-                });
-
-            var right = rightConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    { 1, 2 },
-                    { 3, 4 },
-                    { 5, 6 }
-                });
-
-            var expected = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    { 22, 28 },
-                    { 49, 64 }
-                });
-
-            // contract a 2*3 with a 3*2 tensor, summing on 2*(3) and (3)*2 to produce a 2*2 tensor
-            var actual = TensorOperations.Contract(left, right, new[] { 1 }, new[] { 0 });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-
-            // contract a 1*2*3*1 with a 3*2 tensor, summing on 1*2*(3)*1 and (3)*2 to produce a 1*2*1*2 tensor
-            var reshapedLeft = left.Reshape(new int[] { 1, 2, 3, 1 });
-            var reshapedExpected = expected.Reshape(new int[] { 1, 2, 1, 2 });
-            actual = TensorOperations.Contract(reshapedLeft, right, new[] { 2 }, new[] { 0 });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, reshapedExpected));
-
-        }
-
-        [Theory]
-        [MemberData(nameof(GetDualTensorConstructors))]
-        public void ContractMismatchedDimensions(TensorConstructor leftConstructor, TensorConstructor rightConstructor)
-        {
-            var left = leftConstructor.CreateFromArray<int>(
-                new[] { 0, 1, 2, 3 });
-
-            var right = rightConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    { 0 },
-                    { 1 },
-                    { 2 }
-                });
-
-            var expected = leftConstructor.CreateFromArray<int>(
-                new[,]
-                {
-                    {0,0,0},
-                    {0,1,2},
-                    {0,2,4},
-                    {0,3,6},
-                });
-
-            Assert.Throws<ArgumentException>(() => TensorOperations.Contract(left, right, new int[] { }, new[] { 1 }));
-
-            // reshape to include dimension of length 1.
-            var leftReshaped = left.Reshape(new[] { 1, (int)left.Length });
-
-            var actual = TensorOperations.Contract(leftReshaped, right, new[] { 0 }, new[] { 1 });
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-        }
-
-        [Theory]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void GetArrayString(TensorConstructor constructor)
-        {
-            var tensor = constructor.CreateFromArray<int>(
-                new[, ,]
-                {
-                    {
-                        {0, 1},
-                        {2, 3},
-                        {4, 5}
-                    },
-                    {
-                        {6, 7},
-                        {8, 9},
-                        {10, 11}
-                    },
-                    {
-                        {12, 13},
-                        {14, 15},
-                        {16, 17}
-                    },
-                    {
-                        {18, 19},
-                        {20, 21},
-                        {22, 23}
-                    }
-                });
-
-            var expected =
-@"{
-    {
-        {0,1},
-        {2,3},
-        {4,5}
-    },
-    {
-        {6,7},
-        {8,9},
-        {10,11}
-    },
-    {
-        {12,13},
-        {14,15},
-        {16,17}
-    },
-    {
-        {18,19},
-        {20,21},
-        {22,23}
-    }
-}";
-
-            Assert.Equal(expected, tensor.GetArrayString(), ignoreLineEndingDifferences: !LineEndingsHelper.IsNewLineConsistent);
-
-            var expectedNoSpace = expected.Replace(LineEndingsHelper.CompiledNewline, "").Replace(" ", "");
-            Assert.Equal(expectedNoSpace, tensor.GetArrayString(false));
-        }
-
-        [Theory]
-        [MemberData(nameof(GetTensorAndResultConstructor))]
-        public void ToOtherTensor(TensorConstructor sourceConstructor, TensorConstructor resultConstructor)
-        {
-            var array = new[, ,]
-            {
-                {
-                    {0, 1, 0, 0 },
-                    {0, 0, 0, 9 },
-                    {2, 0, 5, 0 }
-                },
-                {
-                    {3, 0, 0, 6 },
-                    {0, 0, 0, 0 },
-                    {0, 0, 4, 0 }
-                },
-                {
-                    {0, 2, 0, 0 },
-                    {8, 0, 0, 0 },
-                    {0, 0, 12, 0 }
-                },
-                {
-                    {5, 5, 5, 0 },
-                    {0, 0, 0, 15 },
-                    {0, 0, 42, 0 }
-                },
-                {
-                    {1, 0, 0, 4 },
-                    {0, 2, 0, 0 },
-                    {0, 0, 3, 0 }
-                }
-            };
-
-            var source = sourceConstructor.CreateFromArray<int>(array);
-
-            Tensor<int> expected = resultConstructor.CreateFromArray<int>(array);
-
-            Tensor<int> actual;
-
-            switch (resultConstructor.TensorType)
-            {
-                case TensorType.Dense:
-                    actual = source.ToDenseTensor();
-                    break;
-                case TensorType.Sparse:
-                    var actualSparse = source.ToSparseTensor();
-                    actual = actualSparse;
-                    var expectedSparse = expected as SparseTensor<int>;
-                    Assert.Equal(expectedSparse.NonZeroCount, actualSparse.NonZeroCount);
-                    break;
-                case TensorType.CompressedSparse:
-                    var actualCompressedSparse = source.ToCompressedSparseTensor();
-                    actual = actualCompressedSparse;
-                    var expectedCompressedSparse = expected as CompressedSparseTensor<int>;
-                    Assert.Equal(expectedCompressedSparse.NonZeroCount, actualCompressedSparse.NonZeroCount);
-                    if (sourceConstructor.TensorType != TensorType.Dense)
-                    {
-                        // expect packed values when going from sparse -> sparse
-                        Assert.Equal(actualCompressedSparse.NonZeroCount, actualCompressedSparse.Values.Length);
-                    }
-                    break;
-                default:
-                    throw new ArgumentException(nameof(resultConstructor.TensorType));
-            }
-
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, expected));
-            Assert.True(StructuralComparisons.StructuralEqualityComparer.Equals(actual, source));
-        }
-
-        [Theory]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void TestICollectionMembers(TensorConstructor constructor)
-        {
-            var arr = new[,]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            };
-
-            var tensor = constructor.CreateFromArray<int>(arr);
-            ICollection tensorCollection = tensor;
-
-            Assert.Equal(6, tensorCollection.Count);
-
-            Assert.False(tensorCollection.IsSynchronized);
-
-            Assert.True(ReferenceEquals(tensorCollection, tensorCollection.SyncRoot));
-
-            var actual = Array.CreateInstance(typeof(int), tensor.Length);
-            tensorCollection.CopyTo(actual, 0);
-            var expected = constructor.IsReversedStride ?
-                new[] { 1, 4, 2, 5, 3, 6 } :
-                new[] { 1, 2, 3, 4, 5, 6 };
-            Assert.Equal(expected, actual);
-
-            actual = Array.CreateInstance(typeof(int), tensor.Length + 2);
-            tensorCollection.CopyTo(actual, 2);
-            expected = constructor.IsReversedStride ?
-                new[] { 0, 0, 1, 4, 2, 5, 3, 6 } :
-                new[] { 0, 0, 1, 2, 3, 4, 5, 6 };
-            Assert.Equal(expected, actual);
-
-            Assert.Throws<ArgumentNullException>(() => tensorCollection.CopyTo(null, 0));
-            Assert.Throws<ArgumentException>(() => tensorCollection.CopyTo(new int[3, 4], 0));
-            Assert.Throws<ArgumentException>(() => tensorCollection.CopyTo(new int[5], 0));
-            Assert.Throws<ArgumentException>(() => tensorCollection.CopyTo(new int[6], 1));
-        }
-
-        [Theory]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void TestIListMembers(TensorConstructor constructor)
-        {
-            var arr = new[,]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            };
-
-            var tensor = constructor.CreateFromArray<int>(arr);
-            IList tensorList = tensor;
-
-            int expectedIndexValue = constructor.IsReversedStride ? 4 : 2;
-            Assert.Equal(expectedIndexValue, tensorList[1]);
-
-            tensorList[1] = 7;
-            Assert.Equal(7, tensorList[1]);
-            var expected = constructor.IsReversedStride ?
-                new[] { 1, 7, 2, 5, 3, 6 } :
-                new[] { 1, 7, 3, 4, 5, 6 };
-            Assert.Equal(expected, tensor);
-
-            Assert.True(tensorList.IsFixedSize);
-            Assert.False(tensorList.IsReadOnly);
-
-            Assert.Throws<InvalidOperationException>(() => (tensorList).Add(8));
-
-            Assert.True(tensorList.Contains(5));
-            Assert.True(tensorList.Contains(6));
-            Assert.False(tensorList.Contains(0));
-            Assert.False(tensorList.Contains(42));
-            Assert.False(tensorList.Contains("foo"));
-
-            Assert.Equal(constructor.IsReversedStride ? 3 : 4, tensorList.IndexOf(5));
-            Assert.Equal(5, tensorList.IndexOf(6));
-            Assert.Equal(-1, tensorList.IndexOf(0));
-            Assert.Equal(-1, tensorList.IndexOf(42));
-
-            Assert.Throws<InvalidOperationException>(() => (tensorList).Insert(2, 5));
-            Assert.Throws<InvalidOperationException>(() => (tensorList).Remove(1));
-            Assert.Throws<InvalidOperationException>(() => (tensorList).RemoveAt(0));
-
-            tensorList.Clear();
-            Assert.Equal(new[] { 0, 0, 0, 0, 0, 0 }, tensor);
-        }
-
-        [Theory]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void TestICollectionTMembers(TensorConstructor constructor)
-        {
-            var arr = new[,]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            };
-
-            var tensor = constructor.CreateFromArray<int>(arr);
-            ICollection<int> tensorCollection = tensor;
-
-            Assert.Equal(6, tensorCollection.Count);
-            Assert.False(tensorCollection.IsReadOnly);
-
-            Assert.Throws<InvalidOperationException>(() => tensorCollection.Add(8));
-            Assert.Throws<InvalidOperationException>(() => tensorCollection.Remove(1));
-
-            Assert.True(tensorCollection.Contains(5));
-            Assert.True(tensorCollection.Contains(6));
-            Assert.False(tensorCollection.Contains(0));
-            Assert.False(tensorCollection.Contains(42));
-
-            var actual = new int[tensor.Length];
-            tensorCollection.CopyTo(actual, 0);
-            var expected = constructor.IsReversedStride ?
-                new[] { 1, 4, 2, 5, 3, 6 } :
-                new[] { 1, 2, 3, 4, 5, 6 };
-            Assert.Equal(expected, actual);
-
-            actual = new int[tensor.Length + 2];
-            tensorCollection.CopyTo(actual, 2);
-            expected = constructor.IsReversedStride ?
-                new[] { 0, 0, 1, 4, 2, 5, 3, 6 } :
-                new[] { 0, 0, 1, 2, 3, 4, 5, 6 };
-            Assert.Equal(expected, actual);
-
-            Assert.Throws<ArgumentNullException>(() => tensorCollection.CopyTo(null, 0));
-            Assert.Throws<ArgumentException>(() => tensorCollection.CopyTo(new int[5], 0));
-            Assert.Throws<ArgumentException>(() => tensorCollection.CopyTo(new int[6], 1));
-
-            tensorCollection.Clear();
-            Assert.Equal(new[] { 0, 0, 0, 0, 0, 0 }, tensor);
-        }
-
-        [Theory]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void TestIListTMembers(TensorConstructor constructor)
-        {
-            var arr = new[,]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            };
-
-            var tensor = constructor.CreateFromArray<int>(arr);
-            IList<int> tensorList = tensor;
-
-            int expectedIndexValue = constructor.IsReversedStride ? 4 : 2;
-            Assert.Equal(expectedIndexValue, tensorList[1]);
-
-            tensorList[1] = 7;
-            Assert.Equal(7, tensorList[1]);
-            var expected = constructor.IsReversedStride ?
-                new[] { 1, 7, 2, 5, 3, 6 } :
-                new[] { 1, 7, 3, 4, 5, 6 };
-            Assert.Equal(expected, tensor);
-
-            Assert.Equal(constructor.IsReversedStride ? 3 : 4, tensorList.IndexOf(5));
-            Assert.Equal(5, tensorList.IndexOf(6));
-            Assert.Equal(-1, tensorList.IndexOf(0));
-            Assert.Equal(-1, tensorList.IndexOf(42));
-
-            Assert.Throws<InvalidOperationException>(() => (tensorList).Insert(2, 5));
-            Assert.Throws<InvalidOperationException>(() => (tensorList).RemoveAt(0));
-        }
-
-        [Theory]
-        [MemberData(nameof(GetSingleTensorConstructors))]
-        public void TestIReadOnlyTMembers(TensorConstructor constructor)
-        {
-            var arr = new[,]
-            {
-                { 1, 2, 3 },
-                { 4, 5, 6 }
-            };
-
-            var tensor = constructor.CreateFromArray<int>(arr);
-
-            IReadOnlyCollection<int> tensorCollection = tensor;
-            Assert.Equal(6, tensorCollection.Count);
-
-            IReadOnlyList<int> tensorList = tensor;
-            int expectedIndexValue = constructor.IsReversedStride ? 4 : 2;
-            Assert.Equal(expectedIndexValue, tensorList[1]);
-        }
-
-        [Theory]
-        [MemberData(nameof(GetConstructedTensors))]
-        public void TestGetEnumerator(Tensor<int> tensor)
-        {
-            static IEnumerable<int> GetExpected(Tensor<int> tensor)
-            {
-                for (int index = 0; index < tensor.Length; ++index)
-                    yield return tensor.GetValue(index);
-            }
-
-            Assert.Equal(GetExpected(tensor), tensor);
-        }
-
-        [Theory]
-        [MemberData(nameof(GetConstructedTensors))]
-        public void TestEnumeratorReset(Tensor<int> tensor)
-        {
-            static long AdvanceEnumerator(ref Tensor<int>.Enumerator enumerator, long maxCount)
-            {
-                long count = 0;
-                while (count < maxCount && enumerator.MoveNext())
-                    count++;
-
-                return count;
-            }
-
-            static void TestStepCountIfInRange(Tensor<int> tensor, long stepCount)
-            {
-                if (stepCount < 0 || stepCount > tensor.Length)
-                    return;
-
-                var enumerator = tensor.GetEnumerator();
-                long actualStepCount = AdvanceEnumerator(ref enumerator, stepCount);
-
-                Assert.Equal(stepCount, actualStepCount);
-
-                enumerator.Reset();
-
-                var itemsPostReset = new List<int>();
-                while (enumerator.MoveNext())
-                    itemsPostReset.Add(enumerator.Current);
-
-                Assert.Equal(tensor, itemsPostReset);
-            }
-
-            TestStepCountIfInRange(tensor, 1);
-            TestStepCountIfInRange(tensor, tensor.Length - 1);
-            TestStepCountIfInRange(tensor, tensor.Length / 4);
-            TestStepCountIfInRange(tensor, tensor.Length - tensor.Length / 4);
-            TestStepCountIfInRange(tensor, tensor.Length / 2);
-            TestStepCountIfInRange(tensor, tensor.Length);
-        }
-
-        [Theory]
-        [MemberData(nameof(GetConstructedTensors))]
-        public void TestEnumeratorDispose_DoesNotThrow(Tensor<int> tensor)
-        {
-            var enumerator = tensor.GetEnumerator();
-
-            enumerator.Dispose();
-            enumerator.Dispose();
-        }
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorTestsBase.cs b/src/libraries/System.Numerics.Tensors/tests/TensorTestsBase.cs
deleted file mode 100644
index 9774dd22662e6a..00000000000000
--- a/src/libraries/System.Numerics.Tensors/tests/TensorTestsBase.cs
+++ /dev/null
@@ -1,187 +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.Collections.Generic;
-using System.Linq;
-
-namespace System.Numerics.Tensors.Tests
-{
-    public class TensorTestsBase
-    {
-        public enum TensorType
-        {
-            Dense,
-            Sparse,
-            CompressedSparse
-        };
-
-        public class TensorConstructor
-        {
-            public TensorType TensorType { get; set; }
-
-            public bool IsReversedStride { get; set; }
-
-            public Tensor<T> CreateFromArray<T>(Array array)
-            {
-                switch (TensorType)
-                {
-                    case TensorType.Dense:
-                        return array.ToTensor<T>(IsReversedStride);
-                    case TensorType.Sparse:
-                        return array.ToSparseTensor<T>(IsReversedStride);
-                    case TensorType.CompressedSparse:
-                        return array.ToCompressedSparseTensor<T>(IsReversedStride);
-                }
-
-                throw new ArgumentException(nameof(TensorType));
-            }
-            public Tensor<T> CreateFromDimensions<T>(ReadOnlySpan<int> dimensions)
-            {
-                switch (TensorType)
-                {
-                    case TensorType.Dense:
-                        return new DenseTensor<T>(dimensions, IsReversedStride);
-                    case TensorType.Sparse:
-                        return new SparseTensor<T>(dimensions, IsReversedStride);
-                    case TensorType.CompressedSparse:
-                        return new CompressedSparseTensor<T>(dimensions, IsReversedStride);
-                }
-
-                throw new ArgumentException(nameof(TensorType));
-            }
-
-            public override string ToString()
-            {
-                return $"{TensorType}, {nameof(IsReversedStride)} = {IsReversedStride}";
-            }
-        }
-
-        private static TensorType[] s_tensorTypes = new[]
-        {
-            TensorType.Dense,
-            TensorType.Sparse,
-            TensorType.CompressedSparse
-        };
-
-        private static bool[] s_reverseStrideValues = new[]
-        {
-            false,
-            true
-        };
-
-        public static IEnumerable<object[]> GetSingleTensorConstructors()
-        {
-            foreach (TensorType tensorType in s_tensorTypes)
-            {
-                foreach (bool isReversedStride in s_reverseStrideValues)
-                {
-                    yield return new[]
-                    {
-                        new TensorConstructor()
-                        {
-                            TensorType = tensorType,
-                            IsReversedStride = isReversedStride
-                        }
-                    };
-                }
-            }
-        }
-
-        public static IEnumerable<object[]> GetDualTensorConstructors()
-        {
-            foreach (TensorType leftTensorType in s_tensorTypes)
-            {
-                foreach (TensorType rightTensorType in s_tensorTypes)
-                {
-                    foreach (bool isLeftReversedStride in s_reverseStrideValues)
-                    {
-                        foreach (bool isRightReversedStride in s_reverseStrideValues)
-                        {
-                            yield return new[]
-                            {
-                                new TensorConstructor()
-                                {
-                                    TensorType = leftTensorType,
-                                    IsReversedStride = isLeftReversedStride
-                                },
-                                new TensorConstructor()
-                                {
-                                    TensorType = rightTensorType,
-                                    IsReversedStride = isRightReversedStride
-                                }
-                            };
-                        }
-                    }
-                }
-            }
-        }
-
-        public static IEnumerable<object[]> GetTensorAndResultConstructor()
-        {
-            foreach (TensorType leftTensorType in s_tensorTypes)
-            {
-                foreach (TensorType rightTensorType in s_tensorTypes)
-                {
-                    foreach (bool isReversedStride in s_reverseStrideValues)
-                    {
-                        yield return new[]
-                        {
-                            new TensorConstructor()
-                            {
-                                TensorType = leftTensorType,
-                                IsReversedStride = isReversedStride
-                            },
-                            new TensorConstructor()
-                            {
-                                TensorType = rightTensorType,
-                                IsReversedStride = isReversedStride
-                            }
-                        };
-                    }
-                }
-            }
-        }
-
-        public static IEnumerable<object[]> GetConstructedTensors()
-        {
-            foreach (var ctor in GetSingleTensorConstructors().Select(x => (TensorConstructor)x[0]))
-            {
-                yield return new object[] { ctor.CreateFromArray<int>(Array.Empty<int>()) };
-                yield return new object[] { ctor.CreateFromArray<int>(new[] { 7 }) };
-                yield return new object[] { ctor.CreateFromArray<int>(new[] { 7, 14 }) };
-                yield return new object[] { ctor.CreateFromArray<int>(new[] { 7, 14, 21 }) };
-                yield return new object[]
-                {
-                    ctor.CreateFromArray<int>(new[,]
-                    {
-                        { 3, 6, 9 },
-                        { 5, 10, 15 },
-                        { 7, 14, 21 },
-                        { 11, 22, 33 }
-                    })
-                };
-            }
-        }
-
-        public static NativeMemory<T> NativeMemoryFromArray<T>(T[] array)
-        {
-            return NativeMemoryFromArray<T>((Array)array);
-        }
-
-        public static NativeMemory<T> NativeMemoryFromArray<T>(Array array)
-        {
-            // this silly method takes a managed array and copies it over to unmanaged memory,
-            // **only for test purposes**
-
-            var memory = NativeMemory<T>.Allocate(array.Length);
-            var span = memory.GetSpan();
-            int index = 0;
-            foreach (T item in array)
-            {
-                span[index++] = item;
-            }
-
-            return memory;
-        }
-    }
-}