diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 0b6241008f6fe..7897a41ee6ce2 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -61,35 +61,35 @@ public partial interface IReadOnlyTensor<TSelf, T> : System.Collections.Generic.
         nint FlattenedLength { get; }
         bool IsEmpty { get; }
         bool IsPinned { get; }
-        T this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get; }
-        TSelf this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get; }
-        T this[scoped System.ReadOnlySpan<nint> indexes] { get; }
+        T this[params scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get; }
+        TSelf this[params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get; }
+        T this[params scoped System.ReadOnlySpan<nint> indexes] { get; }
         int Rank { get; }
         System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan();
-        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex);
-        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> range);
-        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<nint> start);
+        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex);
+        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NRange> range);
+        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<nint> start);
         void CopyTo(scoped System.Numerics.Tensors.TensorSpan<T> destination);
         void FlattenTo(scoped System.Span<T> destination);
         void GetLengths(scoped System.Span<nint> destination);
         ref readonly T GetPinnableReference();
         void GetStrides(scoped System.Span<nint> destination);
-        TSelf Slice(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex);
-        TSelf Slice(scoped System.ReadOnlySpan<System.Buffers.NRange> range);
-        TSelf Slice(scoped System.ReadOnlySpan<nint> start);
+        TSelf Slice(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex);
+        TSelf Slice(params scoped System.ReadOnlySpan<System.Buffers.NRange> range);
+        TSelf Slice(params scoped System.ReadOnlySpan<nint> start);
         bool TryCopyTo(scoped System.Numerics.Tensors.TensorSpan<T> destination);
         bool TryFlattenTo(scoped System.Span<T> destination);
     }
     public partial interface ITensor<TSelf, T> : System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable, System.Numerics.Tensors.IReadOnlyTensor<TSelf, T> where TSelf : System.Numerics.Tensors.ITensor<TSelf, T>
     {
         bool IsReadOnly { get; }
-        new T this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get; set; }
-        new TSelf this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get; set; }
-        new T this[scoped System.ReadOnlySpan<nint> indexes] { get; set; }
+        new T this[params scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get; set; }
+        new TSelf this[params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get; set; }
+        new T this[params scoped System.ReadOnlySpan<nint> indexes] { get; set; }
         System.Numerics.Tensors.TensorSpan<T> AsTensorSpan();
-        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex);
-        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> range);
-        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<nint> start);
+        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex);
+        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NRange> range);
+        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<nint> start);
         void Clear();
         static abstract TSelf Create(scoped System.ReadOnlySpan<nint> lengths, bool pinned = false);
         static abstract TSelf Create(scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned = false);
@@ -117,9 +117,9 @@ public readonly ref partial struct ReadOnlyTensorSpan<T>
         public static System.Numerics.Tensors.ReadOnlyTensorSpan<T> Empty { get { throw null; } }
         public nint FlattenedLength { get { throw null; } }
         public bool IsEmpty { get { throw null; } }
-        public ref readonly T this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
-        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } }
-        public ref readonly T this[scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
+        public ref readonly T this[params scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> this[params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } }
+        public ref readonly T this[params scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
         [System.Diagnostics.CodeAnalysis.UnscopedRefAttribute]
         public System.ReadOnlySpan<nint> Lengths { get { throw null; } }
         public int Rank { get { throw null; } }
@@ -143,8 +143,8 @@ public void CopyTo(scoped System.Numerics.Tensors.TensorSpan<T> destination) { }
         public static bool operator ==(System.Numerics.Tensors.ReadOnlyTensorSpan<T> left, System.Numerics.Tensors.ReadOnlyTensorSpan<T> right) { throw null; }
         public static implicit operator System.Numerics.Tensors.ReadOnlyTensorSpan<T> (T[]? array) { throw null; }
         public static bool operator !=(System.Numerics.Tensors.ReadOnlyTensorSpan<T> left, System.Numerics.Tensors.ReadOnlyTensorSpan<T> right) { throw null; }
-        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes) { throw null; }
-        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
         public override string ToString() { throw null; }
         public bool TryCopyTo(scoped System.Numerics.Tensors.TensorSpan<T> destination) { throw null; }
         public bool TryFlattenTo(scoped System.Span<T> destination) { throw null; }
@@ -159,115 +159,197 @@ public ref partial struct Enumerator
     }
     public static partial class Tensor
     {
-        public static System.Numerics.Tensors.TensorSpan<T> AddInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> AddInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AbsInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumberBase<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Abs<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumberBase<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AcoshInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Acosh<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AcosInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AcosPiInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AcosPi<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Acos<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> AddInPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> AddInPlace<T>(System.Numerics.Tensors.Tensor<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Add<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Add<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Add<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Add<T>(System.Numerics.Tensors.Tensor<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Broadcast<T>(System.Numerics.Tensors.Tensor<T> input, scoped System.ReadOnlySpan<nint> shape) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AsinhInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Asinh<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AsinInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AsinPiInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AsinPi<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Asin<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Atan2InPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Atan2PiInPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Atan2Pi<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Atan2<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AtanhInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Atanh<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AtanInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AtanPiInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> AtanPi<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Atan<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> BitwiseAndInPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> BitwiseAnd<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> BitwiseOrInPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> BitwiseOr<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Broadcast<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Broadcast<T>(System.Numerics.Tensors.Tensor<T> input, System.ReadOnlySpan<nint> shape) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CeilingInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Ceiling<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Concatenate<T>(System.ReadOnlySpan<System.Numerics.Tensors.Tensor<T>> tensors, int axis = 0) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> CosInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<TTo> ConvertChecked<TFrom, TTo>(System.Numerics.Tensors.Tensor<TFrom> source) where TFrom : System.IEquatable<TFrom>, System.Numerics.IEqualityOperators<TFrom, TFrom, bool>, System.Numerics.INumberBase<TFrom> where TTo : System.Numerics.INumberBase<TTo> { throw null; }
+        public static System.Numerics.Tensors.Tensor<TTo> ConvertSaturating<TFrom, TTo>(System.Numerics.Tensors.Tensor<TFrom> source) where TFrom : System.IEquatable<TFrom>, System.Numerics.IEqualityOperators<TFrom, TFrom, bool>, System.Numerics.INumberBase<TFrom> where TTo : System.Numerics.INumberBase<TTo> { throw null; }
+        public static System.Numerics.Tensors.Tensor<TTo> ConvertTruncating<TFrom, TTo>(System.Numerics.Tensors.Tensor<TFrom> source) where TFrom : System.IEquatable<TFrom>, System.Numerics.IEqualityOperators<TFrom, TFrom, bool>, System.Numerics.INumberBase<TFrom> where TTo : System.Numerics.INumberBase<TTo> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CopySignInPlace<T>(System.Numerics.Tensors.Tensor<T> input, System.Numerics.Tensors.Tensor<T> sign) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CopySignInPlace<T>(System.Numerics.Tensors.Tensor<T> input, T sign) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CopySign<T>(System.Numerics.Tensors.Tensor<T> input, System.Numerics.Tensors.Tensor<T> sign) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CopySign<T>(System.Numerics.Tensors.Tensor<T> input, T sign) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CoshInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Cosh<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CosineSimilarity<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> CosInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Cos<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CosPiInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CosPi<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Cos<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateAndFillGaussianNormalDistribution<T>(scoped System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateAndFillUniformDistribution<T>(scoped System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CreateAndFillGaussianNormalDistribution<T>(params scoped System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CreateAndFillUniformDistribution<T>(params scoped System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> CreateFromEnumerable<T>(System.Collections.Generic.IEnumerable<T> data) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> CreateUninitialized<T>(scoped System.ReadOnlySpan<nint> lengths, bool pinned = false) where T : System.IEquatable<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> CreateUninitialized<T>(scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned = false) where T : System.IEquatable<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Create<T>(scoped System.ReadOnlySpan<nint> lengths, bool pinned = false) where T : System.IEquatable<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Create<T>(scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned = false) where T : System.IEquatable<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Create<T>(T[] values, scoped System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Create<T>(T[] values, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) where T : System.IEquatable<T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> DivideInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> DivideInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Create<T>(T[] values, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool isPinned = false) where T : System.IEquatable<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CubeRootInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CubeRoot<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> DegreesToRadiansInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> DegreesToRadians<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static T Distance<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> DivideInPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> DivideInPlace<T>(System.Numerics.Tensors.Tensor<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> DivideInPlace<T>(T val, System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> DivideInPlace<T>(T val, System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Divide<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Divide<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Divide<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Divide<T>(System.Numerics.Tensors.Tensor<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Divide<T>(T val, System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Divide<T>(T val, System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
+        public static T Dot<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T>, System.Numerics.IMultiplicativeIdentity<T, T>, System.Numerics.IMultiplyOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Exp10InPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Exp10M1InPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Exp10M1<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Exp10<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Exp2InPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Exp2M1InPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Exp2M1<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Exp2<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> ExpInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> ExpM1InPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> ExpM1<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Exp<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> FilteredUpdate<T>(System.Numerics.Tensors.Tensor<T> tensor, System.Numerics.Tensors.Tensor<bool> filter, System.Numerics.Tensors.Tensor<T> values) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> FilteredUpdate<T>(System.Numerics.Tensors.Tensor<T> tensor, System.Numerics.Tensors.Tensor<bool> filter, T value) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> FloorInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Floor<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
         public static bool GreaterThanAll<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
         public static bool GreaterThanAny<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
         public static System.Numerics.Tensors.Tensor<bool> GreaterThan<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
         public static System.Numerics.Tensors.Tensor<bool> GreaterThan<T>(System.Numerics.Tensors.Tensor<T> left, T right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> HypotenuseInPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Hypotenuse<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Ieee754RemainderInPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Ieee754Remainder<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<int> ILogB<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static int IndexOfMaxMagnitude<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static int IndexOfMax<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static int IndexOfMinMagnitude<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static int IndexOfMin<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> LeadingZeroCountInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> LeadingZeroCount<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
         public static bool LessThanAll<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
         public static bool LessThanAny<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
         public static System.Numerics.Tensors.Tensor<bool> LessThan<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
         public static System.Numerics.Tensors.Tensor<bool> LessThan<T>(System.Numerics.Tensors.Tensor<T> left, T right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Log10InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Log10InPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Log10<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Log10P1InPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Log10P1<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Log10<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Log2InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Log2InPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Log2<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Log2P1InPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Log2P1<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Log2<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> LogInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> LogInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Log<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> LogP1InPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> LogP1<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Log<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static T MaxMagnitude<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static T MaxNumber<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static T Max<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
         public static T Mean<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
         public static TResult Mean<T, TResult>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> where TResult : System.IEquatable<TResult>, System.Numerics.IEqualityOperators<TResult, TResult, bool>, System.Numerics.IFloatingPoint<TResult> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> MultiplyInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> MultiplyInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
+        public static T MinMagnitude<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static T MinNumber<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static T Min<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> MultiplyInPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> MultiplyInPlace<T>(System.Numerics.Tensors.Tensor<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Multiply<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Multiply<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Multiply<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Multiply<T>(System.Numerics.Tensors.Tensor<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
-        public static T Norm<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> NegateInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IUnaryNegationOperators<T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Negate<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IUnaryNegationOperators<T, T> { throw null; }
         public static T Norm<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Permute<T>(System.Numerics.Tensors.Tensor<T> input, scoped System.ReadOnlySpan<int> axis) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Reshape<T>(this System.Numerics.Tensors.TensorSpan<T> input, scoped System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Reshape<T>(this System.Numerics.Tensors.Tensor<T> input, scoped System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Resize<T>(System.Numerics.Tensors.TensorSpan<T> input, scoped System.ReadOnlySpan<nint> shape) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Resize<T>(System.Numerics.Tensors.Tensor<T> input, scoped System.ReadOnlySpan<nint> shape) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Reverse<T>(System.Numerics.Tensors.TensorSpan<T> input, nint axis = -1) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> OnesComplementInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> OnesComplement<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Permute<T>(System.Numerics.Tensors.Tensor<T> input, params scoped System.ReadOnlySpan<int> axis) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> PopCountInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> PopCount<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> PowInPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IPowerFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Pow<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IPowerFunctions<T> { throw null; }
+        public static T Product<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplicativeIdentity<T, T>, System.Numerics.IMultiplyOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> RadiansToDegreesInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> RadiansToDegrees<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> ReciprocalInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Reciprocal<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Reshape<T>(this System.Numerics.Tensors.Tensor<T> input, params scoped System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Resize<T>(System.Numerics.Tensors.Tensor<T> input, System.ReadOnlySpan<nint> shape) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Reverse<T>(System.Numerics.Tensors.Tensor<T> input, nint axis = -1) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> RoundInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Round<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<bool> SequenceEqual<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> SetSlice<T>(this System.Numerics.Tensors.Tensor<T> tensor, System.Numerics.Tensors.Tensor<T> values, scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> SinInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> SetSlice<T>(this System.Numerics.Tensors.Tensor<T> tensor, System.Numerics.Tensors.Tensor<T> values, params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> SigmoidInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Sigmoid<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> SinhInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Sinh<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> SinInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Sin<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> SinPiInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> SinPi<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Sin<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> SoftMaxInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> SoftMax<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T>[] Split<T>(System.Numerics.Tensors.Tensor<T> input, nint numSplits, nint axis) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> SqrtInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> SqrtInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Sqrt<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Sqrt<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Squeeze<T>(System.Numerics.Tensors.Tensor<T> input, int axis = -1) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Stack<T>(System.Numerics.Tensors.Tensor<T>[] input, int axis = 0) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
         public static T StdDev<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T>, System.Numerics.IPowerFunctions<T>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
-        public static TResult StdDev<T, TResult>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> where TResult : System.IEquatable<TResult>, System.Numerics.IEqualityOperators<TResult, TResult, bool>, System.Numerics.IFloatingPoint<TResult> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> SubtractInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> SubtractInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
+        public static TResult StdDev<T, TResult>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T>, System.Numerics.IFloatingPoint<T>, System.Numerics.IPowerFunctions<T>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> where TResult : System.IEquatable<TResult>, System.Numerics.IEqualityOperators<TResult, TResult, bool>, System.Numerics.IFloatingPoint<TResult> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> SubtractInPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> SubtractInPlace<T>(System.Numerics.Tensors.Tensor<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> SubtractInPlace<T>(T val, System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> SubtractInPlace<T>(T val, System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Subtract<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Subtract<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Subtract<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Subtract<T>(System.Numerics.Tensors.Tensor<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Subtract<T>(T val, System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Subtract<T>(T val, System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
-        public static T Sum<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
         public static T Sum<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
-        public static string ToString<T>(this System.Numerics.Tensors.ReadOnlyTensorSpan<T> span, scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
-        public static string ToString<T>(this System.Numerics.Tensors.TensorSpan<T> span, scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> TanhInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Tanh<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> TanInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> TanPiInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> TanPi<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Tan<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> TrailingZeroCountInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> TrailingZeroCount<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Transpose<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> TruncateInPlace<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Truncate<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Unsqueeze<T>(System.Numerics.Tensors.Tensor<T> input, int axis) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> XorInPlace<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Xor<T>(System.Numerics.Tensors.Tensor<T> left, System.Numerics.Tensors.Tensor<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
     }
     public static partial class TensorPrimitives
     {
@@ -422,8 +504,177 @@ public static void Xor<T>(System.ReadOnlySpan<T> x, T y, System.Span<T> destinat
     }
     public static partial class TensorSpan
     {
-        public static System.Numerics.Tensors.TensorSpan<T> AsTensorSpan<T>(this T[]? array, scoped System.ReadOnlySpan<nint> shape) { throw null; }
-        public static bool SequenceEqual<T>(this System.Numerics.Tensors.TensorSpan<T> span, System.Numerics.Tensors.TensorSpan<T> other) where T : System.IEquatable<T>? { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AbsInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumberBase<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Abs<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumberBase<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AcoshInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Acosh<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AcosInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AcosPiInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AcosPi<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Acos<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AddInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AddInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Add<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Add<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AsinhInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Asinh<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AsinInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AsinPiInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AsinPi<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Asin<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AsTensorSpan<T>(this T[]? array, params scoped System.ReadOnlySpan<nint> shape) { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Atan2InPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Atan2PiInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Atan2Pi<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Atan2<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AtanhInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Atanh<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AtanInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AtanPiInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AtanPi<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Atan<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> BitwiseAndInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> BitwiseAnd<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> BitwiseOrInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> BitwiseOr<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Broadcast<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Broadcast<T>(System.Numerics.Tensors.TensorSpan<T> input, System.ReadOnlySpan<nint> shape) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CeilingInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Ceiling<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<TTo> ConvertChecked<TFrom, TTo>(System.Numerics.Tensors.TensorSpan<TFrom> source) where TFrom : System.IEquatable<TFrom>, System.Numerics.IEqualityOperators<TFrom, TFrom, bool>, System.Numerics.INumberBase<TFrom> where TTo : System.Numerics.INumberBase<TTo> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<TTo> ConvertSaturating<TFrom, TTo>(System.Numerics.Tensors.TensorSpan<TFrom> source) where TFrom : System.IEquatable<TFrom>, System.Numerics.IEqualityOperators<TFrom, TFrom, bool>, System.Numerics.INumberBase<TFrom> where TTo : System.Numerics.INumberBase<TTo> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<TTo> ConvertTruncating<TFrom, TTo>(System.Numerics.Tensors.TensorSpan<TFrom> source) where TFrom : System.IEquatable<TFrom>, System.Numerics.IEqualityOperators<TFrom, TFrom, bool>, System.Numerics.INumberBase<TFrom> where TTo : System.Numerics.INumberBase<TTo> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CopySignInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input, System.Numerics.Tensors.TensorSpan<T> sign) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CopySignInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input, T sign) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CopySign<T>(System.Numerics.Tensors.TensorSpan<T> input, System.Numerics.Tensors.TensorSpan<T> sign) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CopySign<T>(System.Numerics.Tensors.TensorSpan<T> input, T sign) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CoshInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Cosh<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CosineSimilarity<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CosInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CosPiInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CosPi<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Cos<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CubeRootInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> CubeRoot<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> DegreesToRadiansInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> DegreesToRadians<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static T Distance<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> DivideInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> DivideInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> DivideInPlace<T>(T val, System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Divide<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Divide<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Divide<T>(T val, System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
+        public static T Dot<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T>, System.Numerics.IMultiplicativeIdentity<T, T>, System.Numerics.IMultiplyOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Exp10InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Exp10M1InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Exp10M1<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Exp10<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Exp2InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Exp2M1InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Exp2M1<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Exp2<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> ExpInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> ExpM1InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> ExpM1<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Exp<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> FloorInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Floor<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> HypotenuseInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Hypotenuse<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Ieee754RemainderInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Ieee754Remainder<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<int> ILogB<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPointIeee754<T> { throw null; }
+        public static int IndexOfMaxMagnitude<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static int IndexOfMax<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static int IndexOfMinMagnitude<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static int IndexOfMin<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> LeadingZeroCountInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> LeadingZeroCount<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Log10InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Log10P1InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Log10P1<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Log10<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Log2InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Log2P1InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Log2P1<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Log2<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> LogInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> LogP1InPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> LogP1<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Log<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ILogarithmicFunctions<T> { throw null; }
+        public static T MaxMagnitude<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static T MaxNumber<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static T Max<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static T Mean<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static TResult Mean<T, TResult>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> where TResult : System.IEquatable<TResult>, System.Numerics.IEqualityOperators<TResult, TResult, bool>, System.Numerics.IFloatingPoint<TResult> { throw null; }
+        public static T MinMagnitude<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static T MinNumber<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static T Min<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> MultiplyInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> MultiplyInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Multiply<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Multiply<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplyOperators<T, T, T>, System.Numerics.IMultiplicativeIdentity<T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> NegateInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IUnaryNegationOperators<T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Negate<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IUnaryNegationOperators<T, T> { throw null; }
+        public static T Norm<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> OnesComplementInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> OnesComplement<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> PopCountInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> PopCount<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> PowInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IPowerFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Pow<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IPowerFunctions<T> { throw null; }
+        public static T Product<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IMultiplicativeIdentity<T, T>, System.Numerics.IMultiplyOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> RadiansToDegreesInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> RadiansToDegrees<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> ReciprocalInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Reciprocal<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Reshape<T>(this System.Numerics.Tensors.TensorSpan<T> input, params scoped System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Resize<T>(System.Numerics.Tensors.TensorSpan<T> input, System.ReadOnlySpan<nint> shape) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Reverse<T>(System.Numerics.Tensors.TensorSpan<T> input, nint axis = -1) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> RoundInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Round<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static bool SequenceEqual<T>(this System.Numerics.Tensors.ReadOnlyTensorSpan<T> span, in System.Numerics.Tensors.ReadOnlyTensorSpan<T> other) where T : System.IEquatable<T>? { throw null; }
+        public static bool SequenceEqual<T>(this System.Numerics.Tensors.TensorSpan<T> span, in System.Numerics.Tensors.ReadOnlyTensorSpan<T> other) where T : System.IEquatable<T>? { throw null; }
+        public static bool SequenceEqual<T>(this System.Numerics.Tensors.TensorSpan<T> span, in System.Numerics.Tensors.TensorSpan<T> other) where T : System.IEquatable<T>? { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> SigmoidInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Sigmoid<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> SinhInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Sinh<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> SinInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> SinPiInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> SinPi<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Sin<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> SoftMaxInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> SoftMax<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IExponentialFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> SqrtInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Sqrt<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IRootFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Squeeze<T>(System.Numerics.Tensors.TensorSpan<T> input, int axis = -1) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static T StdDev<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T>, System.Numerics.IPowerFunctions<T>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
+        public static TResult StdDev<T, TResult>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.INumber<T>, System.Numerics.IFloatingPoint<T>, System.Numerics.IPowerFunctions<T>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> where TResult : System.IEquatable<TResult>, System.Numerics.IEqualityOperators<TResult, TResult, bool>, System.Numerics.IFloatingPoint<TResult> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> SubtractInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> SubtractInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> SubtractInPlace<T>(T val, System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Subtract<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Subtract<T>(System.Numerics.Tensors.TensorSpan<T> input, T val) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Subtract<T>(T val, System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
+        public static T Sum<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> TanhInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Tanh<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IHyperbolicFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> TanInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> TanPiInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> TanPi<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Tan<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ITrigonometricFunctions<T> { throw null; }
+        public static string ToString<T>(this System.Numerics.Tensors.ReadOnlyTensorSpan<T> span, params scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
+        public static string ToString<T>(this System.Numerics.Tensors.TensorSpan<T> span, params scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> TrailingZeroCountInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> TrailingZeroCount<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBinaryInteger<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> TruncateInPlace<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Truncate<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Unsqueeze<T>(System.Numerics.Tensors.TensorSpan<T> input, int axis) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> XorInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Xor<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
     }
     public readonly ref partial struct TensorSpan<T>
     {
@@ -444,9 +695,9 @@ public readonly ref partial struct TensorSpan<T>
         public static System.Numerics.Tensors.TensorSpan<T> Empty { get { throw null; } }
         public nint FlattenedLength { get { throw null; } }
         public bool IsEmpty { get { throw null; } }
-        public ref T this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
-        public System.Numerics.Tensors.TensorSpan<T> this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } set { } }
-        public ref T this[scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
+        public ref T this[params scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
+        public System.Numerics.Tensors.TensorSpan<T> this[params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } set { } }
+        public ref T this[params scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
         [System.Diagnostics.CodeAnalysis.UnscopedRefAttribute]
         public System.ReadOnlySpan<nint> Lengths { get { throw null; } }
         public int Rank { get { throw null; } }
@@ -473,8 +724,8 @@ public void FlattenTo(scoped System.Span<T> destination) { }
         public static implicit operator System.Numerics.Tensors.ReadOnlyTensorSpan<T> (System.Numerics.Tensors.TensorSpan<T> span) { throw null; }
         public static implicit operator System.Numerics.Tensors.TensorSpan<T> (T[]? array) { throw null; }
         public static bool operator !=(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) { throw null; }
-        public System.Numerics.Tensors.TensorSpan<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes) { throw null; }
-        public System.Numerics.Tensors.TensorSpan<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
         public override string ToString() { throw null; }
         public bool TryCopyTo(scoped System.Numerics.Tensors.TensorSpan<T> destination) { throw null; }
         public bool TryFlattenTo(scoped System.Span<T> destination) { throw null; }
@@ -494,26 +745,26 @@ internal Tensor() { }
         public bool IsEmpty { get { throw null; } }
         public bool IsPinned { get { throw null; } }
         public System.Numerics.Tensors.Tensor<T> this[System.Numerics.Tensors.Tensor<bool> filter] { get { throw null; } }
-        public ref T this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
-        public System.Numerics.Tensors.Tensor<T> this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } set { } }
-        public ref T this[scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
+        public ref T this[params scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
+        public System.Numerics.Tensors.Tensor<T> this[params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } set { } }
+        public ref T this[params scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
         public System.ReadOnlySpan<nint> Lengths { get { throw null; } }
         public int Rank { get { throw null; } }
         public System.ReadOnlySpan<nint> Strides { get { throw null; } }
-        T System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
-        System.Numerics.Tensors.Tensor<T> System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } }
-        T System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.this[scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
+        T System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.this[params scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
+        System.Numerics.Tensors.Tensor<T> System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.this[params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } }
+        T System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.this[params scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
         bool System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.IsReadOnly { get { throw null; } }
-        T System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } set { } }
-        T System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.this[scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } set { } }
+        T System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.this[params scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } set { } }
+        T System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.this[params scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } set { } }
         public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan() { throw null; }
-        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex) { throw null; }
-        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> start) { throw null; }
-        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<nint> start) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NRange> start) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<nint> start) { throw null; }
         public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan() { throw null; }
-        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex) { throw null; }
-        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> start) { throw null; }
-        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<nint> start) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NRange> start) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<nint> start) { throw null; }
         public void Clear() { }
         public void CopyTo(System.Numerics.Tensors.TensorSpan<T> destination) { }
         public void Fill(T value) { }
@@ -524,20 +775,21 @@ public void FlattenTo(System.Span<T> destination) { }
         public ref T GetPinnableReference() { throw null; }
         public static implicit operator System.Numerics.Tensors.ReadOnlyTensorSpan<T> (System.Numerics.Tensors.Tensor<T> value) { throw null; }
         public static implicit operator System.Numerics.Tensors.TensorSpan<T> (System.Numerics.Tensors.Tensor<T> value) { throw null; }
-        public System.Numerics.Tensors.Tensor<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex) { throw null; }
-        public System.Numerics.Tensors.Tensor<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NRange> start) { throw null; }
-        public System.Numerics.Tensors.Tensor<T> Slice(scoped System.ReadOnlySpan<nint> start) { throw null; }
+        public static implicit operator System.Numerics.Tensors.Tensor<T> (T[] array) { throw null; }
+        public System.Numerics.Tensors.Tensor<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex) { throw null; }
+        public System.Numerics.Tensors.Tensor<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NRange> start) { throw null; }
+        public System.Numerics.Tensors.Tensor<T> Slice(params scoped System.ReadOnlySpan<nint> start) { throw null; }
         System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
         void System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.GetLengths(System.Span<nint> destination) { }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
         ref readonly T System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.GetPinnableReference() { throw null; }
         void System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.GetStrides(scoped System.Span<nint> destination) { }
-        static System.Numerics.Tensors.Tensor<T> System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.Create(scoped System.ReadOnlySpan<nint> lengths, bool pinned) { throw null; }
-        static System.Numerics.Tensors.Tensor<T> System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.Create(scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned) { throw null; }
-        static System.Numerics.Tensors.Tensor<T> System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.CreateUninitialized(scoped System.ReadOnlySpan<nint> lengths, bool pinned) { throw null; }
-        static System.Numerics.Tensors.Tensor<T> System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.CreateUninitialized(scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned) { throw null; }
-        public string ToString(scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
+        static System.Numerics.Tensors.Tensor<T> System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.Create(System.ReadOnlySpan<nint> lengths, bool pinned) { throw null; }
+        static System.Numerics.Tensors.Tensor<T> System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.Create(System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides, bool pinned) { throw null; }
+        static System.Numerics.Tensors.Tensor<T> System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.CreateUninitialized(System.ReadOnlySpan<nint> lengths, bool pinned) { throw null; }
+        static System.Numerics.Tensors.Tensor<T> System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.CreateUninitialized(System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides, bool pinned) { throw null; }
+        public string ToString(params scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
         public bool TryCopyTo(System.Numerics.Tensors.TensorSpan<T> destination) { throw null; }
         public bool TryFlattenTo(System.Span<T> destination) { throw null; }
     }
diff --git a/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx b/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
index a499e962b07bb..505dc853fcd16 100644
--- a/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
+++ b/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
@@ -219,4 +219,10 @@
   <data name="ThrowArgument_StrideLessThan0" xml:space="preserve">
     <value>Strides cannot be less than 0.</value>
   </data>
+  <data name="Argument_2DTensorRequired" xml:space="preserve">
+    <value>Must be a 2d Tensor.</value>
+  </data>
+  <data name="Argument_IncompatibleDimensions" xml:space="preserve">
+    <value>Incompatible dimensions for provided tensors. left.Lengths[1] == {0} while right.Lengths[1] == {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 485702c370cad..0044dbdd1a4cf 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -16,12 +16,12 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
-    <Compile Include="System\Numerics\Tensors\netcore\Common\IReadOnlyTensor.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorHelpers.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorExtensions.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.Factory.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\ITensor.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\IReadOnlyTensor.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorSpanDebugView.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorSpanExtensions.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\ReadOnlyTensorSpan.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/IReadOnlyTensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs
similarity index 88%
rename from src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/IReadOnlyTensor.cs
rename to src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs
index 75c3b95e87209..e0bf1b94b6ec3 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/IReadOnlyTensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs
@@ -1,12 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Buffers;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace System.Numerics.Tensors
 {
@@ -20,8 +16,8 @@ public interface IReadOnlyTensor<TSelf, T> : IEnumerable<T>
         nint FlattenedLength { get; }
         int Rank { get; }
 
-        T this[params ReadOnlySpan<nint> indexes] { get; }
-        T this[params ReadOnlySpan<NIndex> indexes] { get; }
+        T this[params scoped ReadOnlySpan<nint> indexes] { get; }
+        T this[params scoped ReadOnlySpan<NIndex> indexes] { get; }
         TSelf this[params scoped ReadOnlySpan<NRange> ranges] { get; }
 
         ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan();
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs
index 78fab614d1819..b88169543aa6f 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs
@@ -1,12 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Buffers;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace System.Numerics.Tensors
 {
@@ -26,8 +21,8 @@ public interface ITensor<TSelf, T>
 
         bool IsReadOnly { get; }
 
-        new T this[params ReadOnlySpan<nint> indexes] { get; set; }
-        new T this[params ReadOnlySpan<NIndex> indexes] { get; set; }
+        new T this[params scoped ReadOnlySpan<nint> indexes] { get; set; }
+        new T this[params scoped ReadOnlySpan<NIndex> indexes] { get; set; }
         new TSelf this[params scoped ReadOnlySpan<NRange> ranges] { get; set; }
 
         TensorSpan<T> AsTensorSpan();
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs
index 530bf27993e0f..bad5e28d41ecf 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs
@@ -7,9 +7,7 @@
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Runtime.InteropServices.Marshalling;
-using System.Runtime.Versioning;
-using System.Text;
+using static System.Runtime.InteropServices.JavaScript.JSType;
 using EditorBrowsableAttribute = System.ComponentModel.EditorBrowsableAttribute;
 using EditorBrowsableState = System.ComponentModel.EditorBrowsableState;
 
@@ -43,7 +41,7 @@ public readonly ref struct ReadOnlyTensorSpan<T>
         /// <param name="array">The target array.</param>
         /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
         /// <exception cref="ArrayTypeMismatchException">Thrown when <paramref name="array"/> is covariant and array's type is not exactly T[].</exception>
-        public ReadOnlyTensorSpan(T[]? array) : this(array, 0, [], [])
+        public ReadOnlyTensorSpan(T[]? array) : this(array, 0, [array?.Length ?? 0], [])
         {
         }
 
@@ -81,6 +79,9 @@ public ReadOnlyTensorSpan(T[]? array, Index startIndex, scoped ReadOnlySpan<nint
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ReadOnlyTensorSpan(T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
+            if (lengths.IsEmpty && array != null)
+                lengths = [array.Length];
+
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
             if (array == null)
             {
@@ -92,18 +93,20 @@ public ReadOnlyTensorSpan(T[]? array, int start, scoped ReadOnlySpan<nint> lengt
             if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
                 ThrowHelper.ThrowArrayTypeMismatchException();
 
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths) : strides;
-            nint maxElements = TensorSpanHelpers.ComputeMaxElementCount(strides, lengths);
+            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
+            TensorSpanHelpers.ValidateStrides(strides, lengths);
+            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
+
             if (Environment.Is64BitProcess)
             {
                 // See comment in Span<T>.Slice for how this works.
-                if ((ulong)(uint)start + (ulong)(uint)maxElements > (ulong)(uint)array.Length)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
+                if ((ulong)(uint)start + (ulong)(uint)maxElements >= (ulong)(uint)array.Length && array.Length != 0)
+                    ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
             }
             else
             {
-                if ((uint)start > (uint)array.Length || (uint)maxElements > (uint)(array.Length - start))
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
+                if (((uint)start > (uint)array.Length || (uint)maxElements >= (uint)(array.Length - start)) && array.Length != 0)
+                    ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
             }
 
             _flattenedLength = linearLength;
@@ -115,8 +118,8 @@ public ReadOnlyTensorSpan(T[]? array, int start, scoped ReadOnlySpan<nint> lengt
         }
 
         /// <summary>
-        /// Creates a new <see cref="ReadOnlyTensorSpan{T}"/> over the provided <see cref="Span{T}"/>. The new <see cref="ReadOnlyTensorSpan{T}"/> will
-        /// have a rank of 1 and a length equal to the length of the provided <see cref="Span{T}"/>.
+        /// Creates a new <see cref="ReadOnlyTensorSpan{T}"/> over the provided <see cref="ReadOnlySpan{T}"/>. The new <see cref="ReadOnlyTensorSpan{T}"/> will
+        /// have a rank of 1 and a length equal to the length of the provided <see cref="ReadOnlySpan{T}"/>.
         /// </summary>
         /// <param name="span">The target span.</param>
         public ReadOnlyTensorSpan(ReadOnlySpan<T> span) : this(span, [span.Length], []) { }
@@ -130,18 +133,15 @@ public ReadOnlyTensorSpan(ReadOnlySpan<T> span) : this(span, [span.Length], [])
         /// <param name="strides">The strides for each dimension. Will be automatically calculated if not provided.</param>
         public ReadOnlyTensorSpan(ReadOnlySpan<T> span, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
+            if (lengths.IsEmpty)
+                lengths = [span.Length];
+
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            if (span.IsEmpty)
-            {
-                if (linearLength != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-                this = default;
-                return; // returns default
-            }
 
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths) : strides;
-            nint maxElements = TensorSpanHelpers.ComputeMaxElementCount(strides, lengths);
-            if (maxElements >= span.Length)
+            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
+            TensorSpanHelpers.ValidateStrides(strides, lengths);
+            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
+            if (maxElements >= span.Length && span.Length != 0)
                 ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
 
             _flattenedLength = linearLength;
@@ -157,7 +157,7 @@ public ReadOnlyTensorSpan(ReadOnlySpan<T> span, scoped ReadOnlySpan<nint> length
         /// have a rank of 1 and a length equal to the length of the provided <see cref="Array"/>.
         /// </summary>
         /// <param name="array">The target array.</param>
-        public ReadOnlyTensorSpan(Array? array) : this(array, ReadOnlySpan<int>.Empty, [], []) { }
+        public ReadOnlyTensorSpan(Array? array) : this(array, ReadOnlySpan<int>.Empty, array == null ? [0] : (from dim in Enumerable.Range(0, array.Rank) select (nint)array.GetLength(dim)).ToArray(), []) { }
 
         /// <summary>
         /// Creates a new <see cref="ReadOnlyTensorSpan{T}"/> over the provided <see cref="Array"/> using the specified start offsets, lengths, and strides.
@@ -169,9 +169,10 @@ public ReadOnlyTensorSpan(Array? array) : this(array, ReadOnlySpan<int>.Empty, [
         /// <param name="strides">The strides for each dimension. Will be automatically calculated if not provided.</param>
         public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan<int> start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
+            if (lengths.IsEmpty && array != null)
+                lengths = (from dim in Enumerable.Range(0, array.Rank) select (nint)array.GetLength(dim)).ToArray();
+
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths) : strides;
-            nint startOffset = TensorSpanHelpers.ComputeLinearIndex(start, strides, lengths);
             if (array == null)
             {
                 if (!start.IsEmpty || linearLength != 0)
@@ -182,16 +183,20 @@ public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan<int> start, scoped R
             if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
                 ThrowHelper.ThrowArrayTypeMismatchException();
 
-            nint maxElements = TensorSpanHelpers.ComputeMaxElementCount(strides, lengths);
+            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
+            TensorSpanHelpers.ValidateStrides(strides, lengths);
+
+            nint startOffset = TensorSpanHelpers.ComputeStartOffsetSystemArray(array, start);
+            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
             if (Environment.Is64BitProcess)
             {
                 // See comment in Span<T>.Slice for how this works.
-                if ((ulong)(uint)startOffset + (ulong)(uint)maxElements > (ulong)(uint)array.Length)
+                if ((ulong)(uint)startOffset + (ulong)(uint)maxElements >= (ulong)(uint)array.Length && array.Length != 0)
                     ThrowHelper.ThrowArgumentOutOfRangeException();
             }
             else
             {
-                if ((uint)startOffset > (uint)array.Length || (uint)maxElements > (uint)(array.Length - startOffset))
+                if (((uint)startOffset > (uint)array.Length || (uint)maxElements >= (uint)(array.Length - startOffset)) && array.Length != 0)
                     ThrowHelper.ThrowArgumentOutOfRangeException();
             }
 
@@ -213,9 +218,10 @@ public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan<int> start, scoped R
         /// <param name="strides">The strides for each dimension. Will be automatically calculated if not provided.</param>
         public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan<NIndex> startIndex, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
+            if (lengths.IsEmpty && array != null)
+                lengths = (from dim in Enumerable.Range(0, array.Rank) select (nint)array.GetLength(dim)).ToArray();
+
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths) : strides;
-            nint start = TensorSpanHelpers.ComputeLinearIndex(startIndex, strides, lengths);
             if (array == null)
             {
                 if (!startIndex.IsEmpty || linearLength != 0)
@@ -226,22 +232,26 @@ public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan<NIndex> startIndex,
             if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
                 ThrowHelper.ThrowArrayTypeMismatchException();
 
-            nint maxElements = TensorSpanHelpers.ComputeMaxElementCount(strides, lengths);
+            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
+            TensorSpanHelpers.ValidateStrides(strides, lengths);
+
+            nint startOffset = TensorSpanHelpers.ComputeStartOffsetSystemArray(array, startIndex);
+            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
             if (Environment.Is64BitProcess)
             {
                 // See comment in Span<T>.Slice for how this works.
-                if ((ulong)(uint)start + (ulong)(uint)maxElements > (ulong)(uint)array.Length)
+                if ((ulong)(uint)startOffset + (ulong)(uint)maxElements > (ulong)(uint)array.Length)
                     ThrowHelper.ThrowArgumentOutOfRangeException();
             }
             else
             {
-                if ((uint)start > (uint)array.Length || (uint)maxElements > (uint)(array.Length - start))
+                if ((uint)startOffset > (uint)array.Length || (uint)maxElements >= (uint)(array.Length - startOffset))
                     ThrowHelper.ThrowArgumentOutOfRangeException();
             }
 
             _flattenedLength = linearLength;
             _memoryLength = array.Length;
-            _reference = ref Unsafe.Add(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), (nint)(uint)start /* force zero-extension */);
+            _reference = ref Unsafe.Add(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), (nint)(uint)startOffset /* force zero-extension */);
 
             _lengths = lengths.ToArray();
             _strides = strides.ToArray();
@@ -276,13 +286,21 @@ public unsafe ReadOnlyTensorSpan(T* data, nint dataLength) : this(data, dataLeng
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public unsafe ReadOnlyTensorSpan(T* data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
+            if (dataLength < 0)
+                ThrowHelper.ThrowArgumentOutOfRangeException();
+
             if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
                 ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
 
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths) : strides;
-            nint maxElements = TensorSpanHelpers.ComputeMaxElementCount(strides, lengths);
-            if (maxElements >= dataLength)
+            if (lengths.IsEmpty)
+                lengths = [dataLength];
+
+            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
+
+            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
+            TensorSpanHelpers.ValidateStrides(strides, lengths);
+            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
+            if (maxElements >= dataLength && dataLength != 0)
                 ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
 
             _flattenedLength = linearLength;
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs
index e833c1b8ff607..0bd2f2986ceba 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using Microsoft.VisualBasic;
 
 #pragma warning disable CS8601 // Possible null reference assignment.
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
@@ -22,7 +23,7 @@ public static Tensor<T> Create<T>(scoped ReadOnlySpan<nint> lengths, bool pinned
         {
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
             T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
-            return new Tensor<T>(values, lengths, pinned);
+            return Create(values, lengths, [], pinned);
         }
 
         /// <summary>
@@ -36,7 +37,7 @@ public static Tensor<T> Create<T>(scoped ReadOnlySpan<nint> lengths, scoped Read
         {
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
             T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
-            return new Tensor<T>(values, lengths, strides, pinned);
+            return Create(values, lengths, strides, pinned);
         }
 
         /// <summary>
@@ -47,14 +48,7 @@ public static Tensor<T> Create<T>(scoped ReadOnlySpan<nint> lengths, scoped Read
         /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
         public static Tensor<T> Create<T>(T[] values, scoped ReadOnlySpan<nint> lengths)
-            where T : IEquatable<T>
-        {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            if (linearLength != values.Length)
-                ThrowHelper.ThrowArgument_LengthsMustEqualArrayLength();
-
-            return new Tensor<T>(values, lengths, false);
-        }
+            where T : IEquatable<T> => Create(values, lengths, []);
 
         /// <summary>
         /// Creates a <see cref="Tensor{T}"/> from the provided <paramref name="values"/>. If the product of the
@@ -63,15 +57,12 @@ public static Tensor<T> Create<T>(T[] values, scoped ReadOnlySpan<nint> lengths)
         /// <param name="values">An array of the backing memory.</param>
         /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
         /// <param name="strides">A <see cref="ReadOnlySpan{T}"/> indicating the strides of each dimension.</param>
+        /// <param name="isPinned">A <see cref="bool"/> indicating whether the <paramref name="values"/> were pinned or not.</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public static Tensor<T> Create<T>(T[] values, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        public static Tensor<T> Create<T>(T[] values, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool isPinned = false)
             where T : IEquatable<T>
         {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            if (linearLength != values.Length)
-                ThrowHelper.ThrowArgument_LengthsMustEqualArrayLength();
-
-            return new Tensor<T>(values, lengths, strides, false);
+            return new Tensor<T>(values, lengths, strides, isPinned);
         }
 
         /// <summary>
@@ -80,12 +71,8 @@ public static Tensor<T> Create<T>(T[] values, scoped ReadOnlySpan<nint> lengths,
         /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
         /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
         public static Tensor<T> CreateUninitialized<T>(scoped ReadOnlySpan<nint> lengths, bool pinned = false)
-            where T : IEquatable<T>
-        {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, pinned);
-            return new Tensor<T>(values, lengths, pinned);
-        }
+            where T : IEquatable<T> => CreateUninitialized<T>(lengths, [], pinned);
+
 
         /// <summary>
         /// Creates a <see cref="Tensor{T}"/> and does not initialize it. If <paramref name="pinned"/> is true, the memory will be pinned.
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
index 380e3298f2aca..34311af8aa94a 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
@@ -5,9 +5,12 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Linq;
+using System.Reflection.Metadata.Ecma335;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
+using static System.Runtime.InteropServices.JavaScript.JSType;
 
 #pragma warning disable CS8601 // Possible null reference assignment.
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
@@ -32,7 +35,6 @@ public sealed class Tensor<T>
         /// <summary>
         /// Creates a new empty Tensor.
         /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal Tensor()
         {
             _flattenedLength = 0;
@@ -42,28 +44,43 @@ internal Tensor()
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal Tensor(T[] values, scoped ReadOnlySpan<nint> lengths, bool isPinned = false)
-        {
-            _flattenedLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-
-            _values = values;
-            _lengths = lengths.ToArray();
-            _strides = TensorSpanHelpers.CalculateStrides(_lengths);
-            _isPinned = isPinned;
-        }
+        internal Tensor(T[]? values, ReadOnlySpan<nint> lengths, bool isPinned = false) : this(values, lengths, Array.Empty<nint>(), isPinned) { }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal Tensor(T[] values, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool isPinned = false)
+        internal Tensor(T[]? values, ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides, bool isPinned = false)
         {
-            _flattenedLength = TensorSpanHelpers.CalculateTotalLength(lengths);
+            if (values == null)
+            {
+                if (_flattenedLength != 0)
+                    ThrowHelper.ThrowArgumentOutOfRangeException();
+                _flattenedLength = 0;
+                _values = [];
+                _lengths = [];
+                _strides = [];
+                return; // returns default
+            }
+
+            _lengths = lengths.IsEmpty ? [values.Length] : lengths.ToArray();
+
+            _flattenedLength = TensorSpanHelpers.CalculateTotalLength(_lengths);
+            _strides = strides.IsEmpty ? TensorSpanHelpers.CalculateStrides(_lengths, _flattenedLength) : strides.ToArray();
+            TensorSpanHelpers.ValidateStrides(_strides, _lengths);
+            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(_strides, _lengths);
+
+            if (Environment.Is64BitProcess)
+            {
+                // See comment in Span<T>.Slice for how this works.
+                if ((ulong)(uint)maxElements >= (ulong)(uint)values.Length && values.Length != 0)
+                    ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
+            }
+            else
+            {
+                if (((uint)maxElements >= (uint)(values.Length)) && values.Length != 0)
+                    ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
+            }
 
             _values = values;
-            _lengths = lengths.ToArray();
-            _strides = strides.ToArray();
-            if (strides == Array.Empty<nint>())
-                _strides = TensorSpanHelpers.CalculateStrides(lengths);
             _isPinned = isPinned;
-
         }
 
         /// <summary>
@@ -71,7 +88,7 @@ internal Tensor(T[] values, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySp
         /// </summary>
         /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
         /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
-        static Tensor<T> ITensor<Tensor<T>, T>.Create(scoped ReadOnlySpan<nint> lengths, bool pinned)
+        static Tensor<T> ITensor<Tensor<T>, T>.Create(ReadOnlySpan<nint> lengths, bool pinned)
         {
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
             T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
@@ -84,7 +101,7 @@ static Tensor<T> ITensor<Tensor<T>, T>.Create(scoped ReadOnlySpan<nint> lengths,
         /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
         /// <param name="strides">A <see cref="ReadOnlySpan{T}"/> indicating the strides of each dimension.</param>
         /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
-        static Tensor<T> ITensor<Tensor<T>, T>.Create(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned)
+        static Tensor<T> ITensor<Tensor<T>, T>.Create(ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides, bool pinned)
         {
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
             T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
@@ -96,7 +113,7 @@ static Tensor<T> ITensor<Tensor<T>, T>.Create(scoped ReadOnlySpan<nint> lengths,
         /// </summary>
         /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
         /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
-        static Tensor<T> ITensor<Tensor<T>, T>.CreateUninitialized(scoped ReadOnlySpan<nint> lengths, bool pinned)
+        static Tensor<T> ITensor<Tensor<T>, T>.CreateUninitialized(ReadOnlySpan<nint> lengths, bool pinned)
         {
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
             T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, pinned);
@@ -109,7 +126,7 @@ static Tensor<T> ITensor<Tensor<T>, T>.CreateUninitialized(scoped ReadOnlySpan<n
         /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
         /// <param name="strides">A <see cref="ReadOnlySpan{T}"/> indicating the strides of each dimension.</param>
         /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
-        static Tensor<T> ITensor<Tensor<T>, T>.CreateUninitialized(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned)
+        static Tensor<T> ITensor<Tensor<T>, T>.CreateUninitialized(ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides, bool pinned)
         {
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
             T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, pinned);
@@ -347,6 +364,8 @@ public Tensor<T> this[Tensor<bool> filter]
             }
         }
 
+        public static implicit operator Tensor<T>(T[] array) => new Tensor<T>(array, [array.Length]);
+
         public static implicit operator TensorSpan<T>(Tensor<T> value) => new TensorSpan<T>(ref MemoryMarshal.GetArrayDataReference(value._values), value._lengths, value._strides, value._flattenedLength);
 
         public static implicit operator ReadOnlyTensorSpan<T>(Tensor<T> value) => new ReadOnlyTensorSpan<T>(ref MemoryMarshal.GetArrayDataReference(value._values), value._lengths, value._strides, value.FlattenedLength);
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs
index 4d1fdffceddcc..4927b46eb658a 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs
@@ -6,11 +6,9 @@
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Security.Cryptography;
-using Microsoft.VisualBasic;
 using System.Text;
 using System.Buffers;
-using System.Xml.Linq;
+using static System.Runtime.InteropServices.JavaScript.JSType;
 
 #pragma warning disable CS8601 // Possible null reference assignment.
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
@@ -20,60 +18,6 @@ namespace System.Numerics.Tensors
 {
     public static partial class Tensor
     {
-        #region ToString
-        // REVIEW: WHAT SHOULD WE NAME THIS? WHERE DO WE WANT IT TO LIVE?
-        /// <summary>
-        /// Creates a <see cref="string"/> representation of the <see cref="TensorSpan{T}"/>."/>
-        /// </summary>
-        /// <param name="span">The <see cref="TensorSpan{T}"/> you want to represent as a string.</param>
-        /// <param name="maximumLengths">Maximum Length of each dimension</param>
-        /// <returns>A <see cref="string"/> representation of the <paramref name="span"/></returns>
-        public static string ToString<T>(this TensorSpan<T> span, params scoped ReadOnlySpan<nint> maximumLengths) => ((ReadOnlyTensorSpan<T>)span).ToString(maximumLengths);
-
-        /// <summary>
-        /// Creates a <see cref="string"/> representation of the <see cref="ReadOnlyTensorSpan{T}"/>."/>
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="span">The <see cref="ReadOnlyTensorSpan{T}"/> you want to represent as a string.</param>
-        /// <param name="maximumLengths">Maximum Length of each dimension</param>
-        public static string ToString<T>(this ReadOnlyTensorSpan<T> span, params scoped ReadOnlySpan<nint> maximumLengths)
-        {
-            var sb = new StringBuilder();
-            scoped Span<nint> curIndexes;
-            nint[]? curIndexesArray;
-            if (span.Rank > 6)
-            {
-                curIndexesArray = ArrayPool<nint>.Shared.Rent(span.Rank);
-                curIndexes = curIndexesArray;
-            }
-            else
-            {
-                curIndexesArray = null;
-                curIndexes = stackalloc nint[span.Rank];
-            }
-
-            nint copiedValues = 0;
-
-            T[] values = new T[span.Lengths[span.Rank - 1]];
-            while (copiedValues < span._flattenedLength)
-            {
-                var sp = new ReadOnlyTensorSpan<T>(ref Unsafe.Add(ref span._reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, span.Strides, span.Lengths)), [span.Lengths[span.Rank - 1]], [1], span.Lengths[span.Rank - 1]);
-                sb.Append('{');
-                sp.FlattenTo(values);
-                sb.Append(string.Join(",", values));
-                sb.AppendLine("}");
-
-                TensorSpanHelpers.AdjustIndexes(span.Rank - 2, 1, curIndexes, span._lengths);
-                copiedValues += span.Lengths[span.Rank - 1];
-            }
-
-            if (curIndexesArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexesArray);
-
-            return sb.ToString();
-        }
-        #endregion
-
         #region Resize
         /// <summary>
         /// Creates a new <see cref="Tensor{T}"/>, allocates new memory, and copies the data from <paramref name="input"/>. If the final shape is smaller all data after
@@ -81,7 +25,7 @@ public static string ToString<T>(this ReadOnlyTensorSpan<T> span, params scoped
         /// </summary>
         /// <param name="input">Input <see cref="Tensor{T}"/>.</param>
         /// <param name="shape"><see cref="ReadOnlySpan{T}"/> of the desired new shape.</param>
-        public static Tensor<T> Resize<T>(Tensor<T> input, scoped ReadOnlySpan<nint> shape)
+        public static Tensor<T> Resize<T>(Tensor<T> input, ReadOnlySpan<nint> shape)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>
         {
             nint newSize = TensorSpanHelpers.CalculateTotalLength(shape);
@@ -97,29 +41,23 @@ public static Tensor<T> Resize<T>(Tensor<T> input, scoped ReadOnlySpan<nint> sha
             return output;
         }
 
+        #endregion
+
+        #region Broadcast
         /// <summary>
-        /// Creates a new <see cref="TensorSpan{T}"/>, allocates new managed memory, and copies the data from <paramref name="input"/>. If the final shape is smaller all data after
+        /// Broadcast the data from <paramref name="left"/> to the smallest broadcastable shape compatible with <paramref name="right"/>. Creates a new <see cref="Tensor{T}"/> and allocates new memory.
         /// </summary>
-        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="shape"><see cref="ReadOnlySpan{T}"/> of the desired new shape.</param>
-        public static TensorSpan<T> Resize<T>(TensorSpan<T> input, scoped ReadOnlySpan<nint> shape)
+        /// <param name="left">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">Other <see cref="Tensor{T}"/> to make shapes broadcastable.</param>
+        public static Tensor<T> Broadcast<T>(Tensor<T> left, Tensor<T> right)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>
         {
-            nint newSize = TensorSpanHelpers.CalculateTotalLength(shape);
-            T[] values = new T[newSize];
-            TensorSpan<T> output = new TensorSpan<T>(values, 0, shape, default);
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            if (newSize > input.FlattenedLength)
-                TensorSpanHelpers.Memmove(ospan, span, input.FlattenedLength);
-            else
-                TensorSpanHelpers.Memmove(ospan, span, newSize);
+            nint[] newSize = TensorHelpers.GetSmallestBroadcastableSize(left.Lengths, right.Lengths);
 
-            return output;
+            Tensor<T> intermediate = BroadcastTo(left, newSize);
+            return Tensor.Create(intermediate.ToArray(), intermediate.Lengths);
         }
-        #endregion
 
-        #region Broadcast
         /// <summary>
         /// Broadcast the data from <paramref name="input"/> to the new shape <paramref name="shape"/>. Creates a new <see cref="Tensor{T}"/> and allocates new memory.
         /// If the shape of the <paramref name="input"/> is not compatible with the new shape, an exception is thrown.
@@ -127,7 +65,7 @@ public static TensorSpan<T> Resize<T>(TensorSpan<T> input, scoped ReadOnlySpan<n
         /// <param name="input">Input <see cref="Tensor{T}"/>.</param>
         /// <param name="shape"><see cref="ReadOnlySpan{T}"/> of the desired new shape.</param>
         /// <exception cref="ArgumentException">Thrown when the shapes are not broadcast compatible.</exception>
-        public static Tensor<T> Broadcast<T>(Tensor<T> input, scoped ReadOnlySpan<nint> shape)
+        public static Tensor<T> Broadcast<T>(Tensor<T> input, ReadOnlySpan<nint> shape)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>
         {
             Tensor<T> intermediate = BroadcastTo(input, shape);
@@ -178,49 +116,6 @@ internal static Tensor<T> BroadcastTo<T>(Tensor<T> input, ReadOnlySpan<nint> sha
             return output;
         }
 
-        // Lazy/non-copy broadcasting, internal only for now.
-        /// <summary>
-        /// Broadcast the data from <paramref name="input"/> to the new shape <paramref name="shape"/>. Creates a new <see cref="Tensor{T}"/>
-        /// but no memory is allocated. It manipulates the strides to achieve this affect.
-        /// If the shape of the <paramref name="input"/> is not compatible with the new shape, an exception is thrown.
-        /// </summary>
-        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="shape"><see cref="ReadOnlySpan{T}"/> of the desired new shape.</param>
-        /// <exception cref="ArgumentException">Thrown when the shapes are not broadcast compatible.</exception>
-        internal static TensorSpan<T> BroadcastTo<T>(TensorSpan<T> input, scoped ReadOnlySpan<nint> shape)
-        where T : IEquatable<T>, IEqualityOperators<T, T, bool>
-        {
-            if (input.Lengths.SequenceEqual(shape))
-                return new TensorSpan<T>(ref input._reference, shape, input.Strides, input._memoryLength);
-
-            if (!TensorHelpers.AreShapesBroadcastCompatible(input.Lengths, shape))
-                ThrowHelper.ThrowArgument_ShapesNotBroadcastCompatible();
-
-            nint newSize = TensorSpanHelpers.CalculateTotalLength(shape);
-
-            if (newSize == input.FlattenedLength)
-                return Reshape(input, shape);
-
-            nint[] intermediateShape = TensorHelpers.GetIntermediateShape(input.Lengths, shape.Length);
-            nint[] strides = new nint[shape.Length];
-
-            nint stride = 1;
-
-            for (int i = strides.Length - 1; i >= 0; i--)
-            {
-                if ((intermediateShape[i] == 1 && shape[i] != 1) || (intermediateShape[i] == 1 && shape[i] == 1))
-                    strides[i] = 0;
-                else
-                {
-                    strides[i] = stride;
-                    stride *= intermediateShape[i];
-                }
-            }
-
-            TensorSpan<T> output = new TensorSpan<T>(ref input._reference, shape, strides, input._memoryLength);
-
-            return output;
-        }
         #endregion
 
         #region Reverse
@@ -294,79 +189,6 @@ public static Tensor<T> Reverse<T>(Tensor<T> input, nint axis = -1)
 
             return output;
         }
-
-        /// <summary>
-        /// Reverse the order of elements in the <paramref name="input"/> along the given axis. The shape of the tensor is preserved, but the elements are reordered.
-        /// <paramref name="axis"/> defaults to -1 when not provided, which reverses the entire span.
-        /// </summary>
-        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="axis">Axis along which to reverse over. The default, -1, will reverse over all of the axes of the left span.</param>
-        public static TensorSpan<T> Reverse<T>(TensorSpan<T> input, nint axis = -1)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
-        {
-            if (axis == -1)
-            {
-                nint index = input.FlattenedLength - 1;
-                Span<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-                T temp;
-                for (int i = 0; i <= input.FlattenedLength / 2; i++)
-                {
-                    temp = span[(int)index];
-                    span[(int)index] = span[i];
-                    span[i] = temp;
-                }
-            }
-            else
-            {
-                T[] values = new T[input.FlattenedLength];
-
-                nint copyLength = 1;
-                for (nint i = axis; i < input.Lengths.Length; i++)
-                {
-                    copyLength *= input.Lengths[(int)i];
-                }
-                copyLength /= input.Lengths[(int)axis];
-
-                scoped Span<nint> oIndices;
-                nint[]? oIndicesArray;
-                scoped Span<nint> iIndices;
-                nint[]? iIndicesArray;
-                if (input.Rank > 6)
-                {
-                    oIndicesArray = ArrayPool<nint>.Shared.Rent(input.Rank);
-                    oIndices = oIndicesArray;
-                    iIndicesArray = ArrayPool<nint>.Shared.Rent(input.Rank);
-                    iIndices = iIndicesArray;
-                }
-                else
-                {
-                    oIndicesArray = null;
-                    oIndices = stackalloc nint[input.Rank];
-                    iIndicesArray = null;
-                    iIndices = stackalloc nint[input.Rank];
-                }
-
-                iIndices[(int)axis] = input.Lengths[(int)axis] - 1;
-                nint copiedValues = 0;
-                TensorSpan<T> islice = input.Slice(input.Lengths);
-                while (copiedValues < input.FlattenedLength)
-                {
-                    TensorSpanHelpers.Memmove(ref Unsafe.Add(ref values, TensorSpanHelpers.ComputeLinearIndex(oIndices, input.Strides, input.Lengths)), ref Unsafe.Add(ref islice._reference, TensorSpanHelpers.ComputeLinearIndex(iIndices, islice.Strides, islice.Lengths)), copyLength);
-                    TensorSpanHelpers.AdjustIndexes((int)axis, 1, oIndices, input.Lengths);
-                    TensorSpanHelpers.AdjustIndexesDown((int)axis, 1, iIndices, input.Lengths);
-                    copiedValues += copyLength;
-                }
-                TensorSpanHelpers.Memmove(ref input._reference, ref values[0], input.FlattenedLength);
-
-                if (oIndicesArray != null && iIndicesArray != null)
-                {
-                    ArrayPool<nint>.Shared.Return(oIndicesArray);
-                    ArrayPool<nint>.Shared.Return(iIndicesArray);
-                }
-            }
-
-            return input;
-        }
         #endregion
 
         #region Split
@@ -453,7 +275,7 @@ public static Tensor<T>[] Split<T>(Tensor<T> input, nint numSplits, nint axis)
         /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
         /// <param name="values">The values you want to set in the <paramref name="tensor"/>.</param>
         /// <param name="ranges">The ranges you want to set.</param>
-        public static Tensor<T> SetSlice<T>(this Tensor<T> tensor, Tensor<T> values, params scoped ReadOnlySpan<NRange> ranges)
+        public static Tensor<T> SetSlice<T>(this Tensor<T> tensor, Tensor<T> values, params ReadOnlySpan<NRange> ranges)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>
         {
             TensorSpan<T> srcSpan;
@@ -1003,7 +825,7 @@ public static Tensor<T> Stack<T>(Tensor<T>[] input, int axis = 0)
         /// </summary>
         /// <param name="input"><see cref="Tensor{T}"/> you want to reshape.</param>
         /// <param name="lengths"><see cref="ReadOnlySpan{T}"/> with the new dimensions.</param>
-        public static Tensor<T> Reshape<T>(this Tensor<T> input, params scoped ReadOnlySpan<nint> lengths)
+        public static Tensor<T> Reshape<T>(this Tensor<T> input, params ReadOnlySpan<nint> lengths)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>
         {
             nint[] arrLengths = lengths.ToArray();
@@ -1030,41 +852,6 @@ public static Tensor<T> Reshape<T>(this Tensor<T> input, params scoped ReadOnlyS
             nint[] strides = TensorSpanHelpers.CalculateStrides(arrLengths);
             return new Tensor<T>(input._values, arrLengths, strides);
         }
-
-        /// <summary>
-        /// Reshapes the <paramref name="input"/> tensor to the specified <paramref name="lengths"/>. If one of the lengths is -1, it will be calculated automatically.
-        /// Does not change the length of the underlying memory nor does it allocate new memory. If the new shape is not compatible with the old shape,
-        /// an exception is thrown.
-        /// </summary>
-        /// <param name="input"><see cref="TensorSpan{T}"/> you want to reshape.</param>
-        /// <param name="lengths"><see cref="ReadOnlySpan{T}"/> with the new dimensions.</param>
-        public static TensorSpan<T> Reshape<T>(this TensorSpan<T> input, params scoped ReadOnlySpan<nint> lengths)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
-        {
-            nint[] arrLengths = lengths.ToArray();
-            // Calculate wildcard info.
-            if (lengths.Contains(-1))
-            {
-                if (lengths.Count(-1) > 1)
-                    ThrowHelper.ThrowArgument_OnlyOneWildcard();
-                nint tempTotal = input.FlattenedLength;
-                for (int i = 0; i < lengths.Length; i++)
-                {
-                    if (lengths[i] != -1)
-                    {
-                        tempTotal /= lengths[i];
-                    }
-                }
-                arrLengths[lengths.IndexOf(-1)] = tempTotal;
-
-            }
-
-            nint tempLinear = TensorSpanHelpers.CalculateTotalLength(arrLengths);
-            if (tempLinear != input.FlattenedLength)
-                ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
-            nint[] strides = TensorSpanHelpers.CalculateStrides(arrLengths);
-            return new TensorSpan<T>(ref input._reference, arrLengths, strides, input._memoryLength);
-        }
         #endregion
 
         #region Squeeze
@@ -1274,12 +1061,18 @@ public static T StdDev<T>(Tensor<T> input)
         /// <param name="input">The <see cref="Tensor{T}"/> to take the standard deviation of.</param>
         /// <returns><typeparamref name="TResult"/> representing the standard deviation.</returns>
         public static TResult StdDev<T, TResult>(Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>, IFloatingPoint<T>, IPowerFunctions<T>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
             where TResult : IEquatable<TResult>, IEqualityOperators<TResult, TResult, bool>, IFloatingPoint<TResult>
 
         {
-            T sum = Tensor.Sum(input);
-            return TResult.CreateChecked(TResult.CreateChecked(sum) / TResult.CreateChecked(input.FlattenedLength));
+            T mean = Mean(input);
+            Span<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Span<T> output = new T[input._flattenedLength].AsSpan();
+            TensorPrimitives.Subtract(span, mean, output);
+            TensorPrimitives.Abs(output, output);
+            TensorPrimitives.Pow((ReadOnlySpan<T>)output, T.CreateChecked(2), output);
+            T sum = TensorPrimitives.Sum((ReadOnlySpan<T>)output);
+            return TResult.CreateChecked(sum / T.CreateChecked(input.FlattenedLength));
         }
 
         #endregion
@@ -1294,7 +1087,7 @@ public static T Mean<T>(Tensor<T> input)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
 
         {
-            T sum = Tensor.Sum(input);
+            T sum = Sum(input);
             return T.CreateChecked(sum / T.CreateChecked(input.FlattenedLength));
         }
 
@@ -1308,7 +1101,7 @@ public static TResult Mean<T, TResult>(Tensor<T> input)
             where TResult : IEquatable<TResult>, IEqualityOperators<TResult, TResult, bool>, IFloatingPoint<TResult>
 
         {
-            T sum = Tensor.Sum(input);
+            T sum = Sum(input);
             return TResult.CreateChecked(TResult.CreateChecked(sum) / TResult.CreateChecked(input.FlattenedLength));
         }
 
@@ -1338,7 +1131,7 @@ public static Tensor<T> Transpose<T>(Tensor<T> input)
         /// </summary>
         /// <param name="input">Input <see cref="Tensor{T}"/></param>
         /// <param name="axis"><see cref="ReadOnlySpan{T}"/> with the new axis ordering.</param>
-        public static Tensor<T> Permute<T>(Tensor<T> input, params scoped ReadOnlySpan<int> axis)
+        public static Tensor<T> Permute<T>(Tensor<T> input, params ReadOnlySpan<int> axis)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>
         {
             if (input.Rank == 1)
@@ -1410,614 +1203,505 @@ public static Tensor<T> Permute<T>(Tensor<T> input, params scoped ReadOnlySpan<i
         #endregion
 
         #region TensorPrimitives
-        #region Multiply
+        #region Abs
         /// <summary>
-        /// Multiplies each element of <paramref name="input"/> with <paramref name="val"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// Takes the absolute value of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="input">Input <see cref="Tensor{T}"/></param>
-        /// <param name="val"><typeparamref name="T"/> value to multiply by.</param>
-        public static Tensor<T> Multiply<T>(Tensor<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> Abs<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumberBase<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Multiply(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Abs);
         }
 
         /// <summary>
-        /// Multiplies each element of <paramref name="input"/> with <paramref name="val"/> in place.
+        /// Takes the absolute of each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="input">Input <see cref="Tensor{T}"/></param>
-        /// <param name="val"><typeparamref name="T"/> value to multiply by.</param>
-        public static Tensor<T> MultiplyInPlace<T>(Tensor<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> AbsInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumberBase<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Multiply(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Abs, true);
         }
+        #endregion
 
+        #region Acos
         /// <summary>
-        /// Multiplies each element of <paramref name="left"/> with <paramref name="right"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// Takes the inverse cosine of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="left">Left <see cref="Tensor{T}"/> for multiplication.</param>
-        /// <param name="right">Right <see cref="Tensor{T}"/> for multiplication.</param>
-        public static Tensor<T> Multiply<T>(Tensor<T> left, Tensor<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> Acos<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Multiply);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Acos);
         }
 
         /// <summary>
-        /// Multiplies each element of <paramref name="left"/> with <paramref name="right"/> in place.
-        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// Takes the inverse cosine of each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="left">Left <see cref="Tensor{T}"/> for multiplication.</param>
-        /// <param name="right">Right <see cref="Tensor{T}"/> for multiplication.</param>
-        public static Tensor<T> MultiplyInPlace<T>(Tensor<T> left, Tensor<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> AcosInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Multiply, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Acos, true);
         }
+        #endregion
 
+        #region Acosh
         /// <summary>
-        /// Multiplies each element of <paramref name="input"/> with <paramref name="val"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// Takes the inverse hyperbolic cosine of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="input">Input <see cref="TensorSpan{T}"/></param>
-        /// <param name="val"><typeparamref name="T"/> value to multiply by.</param>
-        public static TensorSpan<T> Multiply<T>(TensorSpan<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> Acosh<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            T[] values = new T[input.FlattenedLength];
-            TensorSpan<T> output = new TensorSpan<T>(values, 0, input.Lengths, default);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Multiply(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Acosh);
         }
 
         /// <summary>
-        /// Multiplies each element of <paramref name="input"/> with <paramref name="val"/> in place.
+        /// Takes the inverse hyperbolic cosine of each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="input">Input <see cref="TensorSpan{T}"/></param>
-        /// <param name="val"><typeparamref name="T"/> value to multiply by.</param>
-        public static TensorSpan<T> MultiplyInPlace<T>(TensorSpan<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> AcoshInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            TensorSpan<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Multiply(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Acosh, true);
         }
+        #endregion
 
+        #region AcosPi
         /// <summary>
-        /// Multiplies each element of <paramref name="left"/> with <paramref name="right"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// Takes the inverse hyperbolic cosine divided by pi of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="left">Left <see cref="TensorSpan{T}"/> for multiplication.</param>
-        /// <param name="right">Right <see cref="TensorSpan{T}"/> for multiplication.</param>
-        public static TensorSpan<T> Multiply<T>(TensorSpan<T> left, TensorSpan<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> AcosPi<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Multiply);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AcosPi);
         }
 
         /// <summary>
-        /// Multiplies each element of <paramref name="left"/> with <paramref name="right"/> in place.
-        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// Takes the inverse hyperbolic cosine divided by pi of each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="left">Left <see cref="TensorSpan{T}"/> for multiplication.</param>
-        /// <param name="right">Right <see cref="TensorSpan{T}"/> for multiplication.</param>
-        public static TensorSpan<T> MultiplyInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> AcosPiInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Multiply, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AcosPi, true);
         }
         #endregion
 
-        #region Divide
+        #region Add
         /// <summary>
-        /// Divides each element of <paramref name="input"/> by <paramref name="val"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// Adds each element of <paramref name="left"/> to each element of <paramref name="right"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="input">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="val">The divisor</param>
-        public static Tensor<T> Divide<T>(Tensor<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="left">The <see cref="Tensor{T}"/> of values to add.</param>
+        /// <param name="right">The second <see cref="Tensor{T}"/> of values to add.</param>
+        public static Tensor<T> Add<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Divide(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Add);
         }
 
         /// <summary>
-        /// Divides each element of <paramref name="input"/> by <paramref name="val"/> in place.
+        /// Adds each element of <paramref name="left"/> to each element of <paramref name="right"/> in place.
         /// </summary>
-        /// <param name="input">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="val">The divisor.</param>
-        public static Tensor<T> DivideInPlace<T>(Tensor<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="left">The <see cref="Tensor{T}"/> of values to add.</param>
+        /// <param name="right">The second <see cref="Tensor{T}"/> of values to add.</param>
+        public static Tensor<T> AddInPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Divide(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Add, true);
         }
 
         /// <summary>
-        /// Divides <paramref name="val"/> by each element of <paramref name="input"/> and returns a new <see cref="Tensor{T}"/> with the result."/>
+        /// Adds <paramref name="val"/> to each element of <paramref name="input"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="val">The value to be divided.</param>
-        /// <param name="input">The <see cref="Tensor{T}"/> divisor.</param>
-        public static Tensor<T> Divide<T>(T val, Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> of values to add.</param>
+        /// <param name="val">The <typeparamref name="T"/> to add to each element of <paramref name="input"/>.</param>
+        public static Tensor<T> Add<T>(Tensor<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Divide(val, span, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInTInSpanOut(input, val, TensorPrimitives.Add);
         }
 
         /// <summary>
-        /// Divides <paramref name="val"/> by each element of <paramref name="input"/> in place.
+        /// Adds <paramref name="val"/> to each element of <paramref name="input"/> in place.
         /// </summary>
-        /// <param name="val">The value to be divided.</param>
-        /// <param name="input">The <see cref="Tensor{T}"/> divisor.</param>
-        public static Tensor<T> DivideInPlace<T>(T val, Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> of values to add.</param>
+        /// <param name="val">The <typeparamref name="T"/> to add to each element of <paramref name="input"/>.</param>
+        public static Tensor<T> AddInPlace<T>(Tensor<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Divide(val, span, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInTInSpanOut(input, val, TensorPrimitives.Add, true);
+
         }
+        #endregion
 
+        #region Asin
         /// <summary>
-        /// Divides each element of <paramref name="left"/> by its corresponding element in <paramref name="right"/> and returns
-        /// a new <see cref="Tensor{T}"/> with the result.
+        /// Takes the inverse sin of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="left">The <see cref="Tensor{T}"/> to be divided.</param>
-        /// <param name="right">The <see cref="Tensor{T}"/> divisor.</param>
-        public static Tensor<T> Divide<T>(Tensor<T> left, Tensor<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> Asin<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Divide);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Asin);
         }
 
         /// <summary>
-        /// Divides each element of <paramref name="left"/> by its corresponding element in <paramref name="right"/> in place.
+        /// Takes the inverse sine each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="left">The <see cref="Tensor{T}"/> to be divided.</param>
-        /// <param name="right">The <see cref="Tensor{T}"/> divisor.</param>
-        public static Tensor<T> DivideInPlace<T>(Tensor<T> left, Tensor<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> AsinInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Divide, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Asin, true);
         }
+        #endregion
 
+        #region Asinh
         /// <summary>
-        /// Divides each element of <paramref name="input"/> by <paramref name="val"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// Takes the inverse hyperbolic sine of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="val">The divisor</param>
-        public static TensorSpan<T> Divide<T>(TensorSpan<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> Asinh<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            T[] values = new T[input.FlattenedLength];
-            TensorSpan<T> output = new TensorSpan<T>(values, 0, input.Lengths, default);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Divide(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Asinh);
         }
 
         /// <summary>
-        /// Divides each element of <paramref name="input"/> by <paramref name="val"/> in place.
+        /// Takes the inverse hyperbolic sine each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="val">The divisor</param>
-        public static TensorSpan<T> DivideInPlace<T>(TensorSpan<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> AsinhInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            TensorSpan<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Divide(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Asinh, true);
         }
+        #endregion
 
+        #region AsinPi
         /// <summary>
-        /// Divides <paramref name="val"/> by each element of <paramref name="input"/> and returns a new <see cref="TensorSpan{T}"/> with the result."/>
+        /// Takes the inverse hyperbolic sine divided by pi of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="val">The value to be divided.</param>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> divisor.</param>
-        public static TensorSpan<T> Divide<T>(T val, TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> AsinPi<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            T[] values = new T[input.FlattenedLength];
-            TensorSpan<T> output = new TensorSpan<T>(values, 0, input.Lengths, default);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Divide(val, span, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AsinPi);
         }
 
         /// <summary>
-        /// Divides <paramref name="val"/> by each element of <paramref name="input"/> in place.
+        /// Takes the inverse hyperbolic sine divided by pi of each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="val">The value to be divided.</param>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> divisor.</param>
-        public static TensorSpan<T> DivideInPlace<T>(T val, TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> AsinPiInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            TensorSpan<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Divide(val, span, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AsinPi, true);
         }
+        #endregion
 
+        #region Atan
         /// <summary>
-        /// Divides each element of <paramref name="left"/> by its corresponding element in <paramref name="right"/> and returns
-        /// a new <see cref="TensorSpan{T}"/> with the result.
+        /// Takes the arc tangent of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="left">The <see cref="TensorSpan{T}"/> to be divided.</param>
-        /// <param name="right">The <see cref="TensorSpan{T}"/> divisor.</param>
-        public static TensorSpan<T> Divide<T>(TensorSpan<T> left, TensorSpan<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="input">The input <see cref="Tensor{T}"/></param>
+        public static Tensor<T> Atan<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Divide);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Atan);
         }
 
         /// <summary>
-        /// Divides each element of <paramref name="left"/> by its corresponding element in <paramref name="right"/> in place.
+        /// Takes the arc tangent of each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="left">The <see cref="TensorSpan{T}"/> to be divided.</param>
-        /// <param name="right">The <see cref="TensorSpan{T}"/> divisor.</param>
-        public static TensorSpan<T> DivideInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        /// <param name="input">The input <see cref="Tensor{T}"/></param>
+        public static Tensor<T> AtanInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Divide, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Atan, true);
         }
-
         #endregion
 
-        #region Subtract
+        #region Atan2
         /// <summary>
-        /// Subtracts <paramref name="val"/> from each element of <paramref name="input"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// Takes the arc tangent of the two input <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/>.</param>
-        /// <param name="val">The <typeparamref name="T"/> to subtract.</param>
-        public static Tensor<T> Subtract<T>(Tensor<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="left">The left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Atan2<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Subtract(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Atan2);
         }
 
         /// <summary>
-        /// Subtracts <paramref name="val"/> from each element of <paramref name="input"/> in place.
+        /// Takes the arc tangent of the two input <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/>.</param>
-        /// <param name="val">The <typeparamref name="T"/> to subtract.</param>
-        public static Tensor<T> SubtractInPlace<T>(Tensor<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="left">The left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Atan2InPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Subtract(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Atan2, true);
         }
+        #endregion
 
+        #region Atan2Pi
         /// <summary>
-        /// Subtracts each element of <paramref name="input"/> from <paramref name="val"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// Takes the arc tangent of the two input <see cref="Tensor{T}"/>, divides each element by pi, and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="val">The <typeparamref name="T"/> to be subtracted from.</param>
-        /// <param name="input">The <see cref="Tensor{T}"/> of values to subtract.</param>
-        public static Tensor<T> Subtract<T>(T val, Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="left">The left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Atan2Pi<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Subtract(val, span, ospan);
-            return output;
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Atan2Pi);
         }
 
         /// <summary>
-        /// Subtracts each element of <paramref name="input"/> from <paramref name="val"/> in place.
+        /// Takes the arc tangent of the two input <see cref="Tensor{T}"/>, divides each element by pi in place.
         /// </summary>
-        /// <param name="val">The <typeparamref name="T"/> to be subtracted from.</param>
-        /// <param name="input">The <see cref="Tensor{T}"/> of values to subtract.</param>
-        public static Tensor<T> SubtractInPlace<T>(T val, Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="left">The left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Atan2PiInPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Subtract(val, span, ospan);
-            return output;
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Atan2Pi, true);
         }
+        #endregion
 
+        #region Atanh
         /// <summary>
-        /// Subtracts each element of <paramref name="left"/> from <paramref name="right"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// Takes the inverse hyperbolic tangent of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="left">The <see cref="Tensor{T}"/> with values to be subtracted from.</param>
-        /// <param name="right">The <see cref="Tensor{T}"/> with values to subtract.</param>
-        public static Tensor<T> Subtract<T>(Tensor<T> left, Tensor<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Atanh<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Subtract);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Atanh);
         }
 
         /// <summary>
-        /// Subtracts each element of <paramref name="left"/> from <paramref name="right"/> in place.
+        /// Takes the inverse hyperbolic tangent of each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="left">The <see cref="Tensor{T}"/> with values to be subtracted from.</param>
-        /// <param name="right">The <see cref="Tensor{T}"/> with values to subtract.</param>
-        public static Tensor<T> SubtractInPlace<T>(Tensor<T> left, Tensor<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> AtanhInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Subtract, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Atanh, true);
         }
+        #endregion
 
+        #region AtanPi
         /// <summary>
-        /// Subtracts <paramref name="val"/> from each element of <paramref name="input"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// Takes the inverse hyperbolic tangent divided by pi of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> with values to be subtracted from.</param>
-        /// <param name="val">The <typeparamref name="T"/> value to subtract.</param>
-        public static TensorSpan<T> Subtract<T>(TensorSpan<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="input">The input<see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> AtanPi<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            T[] values = new T[input.FlattenedLength];
-            TensorSpan<T> output = new TensorSpan<T>(values, 0, input.Lengths, default);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Subtract(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AtanPi);
         }
 
         /// <summary>
-        /// Subtracts <paramref name="val"/> from each element of <paramref name="input"/> in place.
+        /// Takes the inverse hyperbolic tangent divided by pi of each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> with values to be subtracted from.</param>
-        /// <param name="val">The <typeparamref name="T"/> value to subtract.</param>
-        public static TensorSpan<T> SubtractInPlace<T>(TensorSpan<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="input">The input<see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> AtanPiInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            TensorSpan<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Subtract(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AtanPi, true);
         }
+        #endregion
 
+        #region BitwiseAnd
         /// <summary>
-        /// Subtracts each element of <paramref name="input"/> from <paramref name="val"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// Computes the element-wise bitwise and of the two input <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="val">The <typeparamref name="T"/> value to be subtracted from.</param>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> values to subtract.</param>
-        public static TensorSpan<T> Subtract<T>(T val, TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="left">The left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> BitwiseAnd<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            T[] values = new T[input.FlattenedLength];
-            TensorSpan<T> output = new TensorSpan<T>(values, 0, input.Lengths, default);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Subtract(val, span, ospan);
-            return output;
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.BitwiseAnd);
         }
 
         /// <summary>
-        /// Subtracts each element of <paramref name="input"/> from <paramref name="val"/> in place.
+        /// Computes the element-wise bitwise and of the two input <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="val">The <typeparamref name="T"/> value to be subtracted from.</param>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> values to subtract.</param>
-        public static TensorSpan<T> SubtractInPlace<T>(T val, TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="left">The left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> BitwiseAndInPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            TensorSpan<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Subtract(val, span, ospan);
-            return output;
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.BitwiseAnd, true);
         }
+        #endregion
 
+        #region BitwiseOr
         /// <summary>
-        /// Subtracts each element of <paramref name="left"/> from <paramref name="right"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// Computes the element-wise bitwise of of the two input <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="left">The <see cref="TensorSpan{T}"/> of values to be subtracted from.</param>
-        /// <param name="right">The <see cref="TensorSpan{T}"/>of values to subtract.</param>
-        public static TensorSpan<T> Subtract<T>(TensorSpan<T> left, TensorSpan<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="left">The left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> BitwiseOr<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Subtract);
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.BitwiseOr);
         }
 
         /// <summary>
-        /// Subtracts each element of <paramref name="left"/> from <paramref name="right"/> in place.
+        /// Computes the element-wise bitwise of of the two input <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="left">The <see cref="TensorSpan{T}"/> of values to be subtracted from.</param>
-        /// <param name="right">The <see cref="TensorSpan{T}"/>of values to subtract.</param>
-        public static TensorSpan<T> SubtractInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        /// <param name="left">The left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> BitwiseOrInPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Subtract, true);
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.BitwiseOr, true);
         }
-
         #endregion
 
-        #region Sum
-
+        #region CubeRoot
         /// <summary>
-        /// Sums all the elements of the <see cref="Tensor{T}"/> and returns the result.
+        /// Computes the element-wise cube root of the input <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/> to sum.</param>
-        public static T Sum<T>(Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        /// <param name="input">The left <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> CubeRoot<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            return TensorPrimitives.Sum(span);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cbrt);
         }
 
         /// <summary>
-        /// Sums all the elements of the <see cref="TensorSpan{T}"/> and returns the result.
+        /// Computes the element-wise cube root of the input <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to sum.</param>
-        public static T Sum<T>(TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        /// <param name="input">The left <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> CubeRootInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            return TensorPrimitives.Sum(span);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cbrt, true);
         }
-
         #endregion
 
-        #region Add
-        /// <summary>
-        /// Adds each element of <paramref name="left"/> to each element of <paramref name="right"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="left">The <see cref="Tensor{T}"/> of values to add.</param>
-        /// <param name="right">The second <see cref="Tensor{T}"/> of values to add.</param>
-        public static Tensor<T> Add<T>(Tensor<T> left, Tensor<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
-        {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Add);
-        }
-
+        #region Ceiling
         /// <summary>
-        /// Adds each element of <paramref name="left"/> to each element of <paramref name="right"/> in place.
+        /// Computes the element-wise ceiling of the input <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="left">The <see cref="Tensor{T}"/> of values to add.</param>
-        /// <param name="right">The second <see cref="Tensor{T}"/> of values to add.</param>
-        public static Tensor<T> AddInPlace<T>(Tensor<T> left, Tensor<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        /// <param name="input">The left <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Ceiling<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Add, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Ceiling);
         }
 
         /// <summary>
-        /// Adds <paramref name="val"/> to each element of <paramref name="input"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// Computes the element-wise ceiling of the input <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/> of values to add.</param>
-        /// <param name="val">The <typeparamref name="T"/> to add to each element of <paramref name="input"/>.</param>
-        public static Tensor<T> Add<T>(Tensor<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        /// <param name="input">The left <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> CeilingInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Add(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Ceiling, true);
         }
+        #endregion
 
+        #region ConvertChecked
         /// <summary>
-        /// Adds <paramref name="val"/> to each element of <paramref name="input"/> in place.
+        /// Copies <paramref name="source"/> to a new <see cref="Tensor{TTO}"/> converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
         /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/> of values to add.</param>
-        /// <param name="val">The <typeparamref name="T"/> to add to each element of <paramref name="input"/>.</param>
-        public static Tensor<T> AddInPlace<T>(Tensor<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        /// <param name="source">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<TTo> ConvertChecked<TFrom, TTo>(Tensor<TFrom> source)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
-            TensorPrimitives.Add(span, val, ospan);
-            return output;
+            return TensorPrimitivesHelperTFromSpanInTToSpanOut<TFrom, TTo>(source, TensorPrimitives.ConvertChecked);
         }
+        #endregion
 
+        #region ConvertSaturating
         /// <summary>
-        /// Adds each element of <paramref name="left"/> to each element of <paramref name="right"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// Copies <paramref name="source"/> to a new <see cref="Tensor{TTO}"/> converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
         /// </summary>
-        /// <param name="left">The first <see cref="TensorSpan{T}"/> of elements to add.</param>
-        /// <param name="right">The second <see cref="TensorSpan{T}"/> of elements to add.</param>
-        public static TensorSpan<T> Add<T>(TensorSpan<T> left, TensorSpan<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        /// <param name="source">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<TTo> ConvertSaturating<TFrom, TTo>(Tensor<TFrom> source)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Add);
+            return TensorPrimitivesHelperTFromSpanInTToSpanOut<TFrom, TTo>(source, TensorPrimitives.ConvertSaturating);
         }
+        #endregion
 
+        #region ConvertTruncating
         /// <summary>
-        /// Adds each element of <paramref name="left"/> to each element of <paramref name="right"/> in place.
+        /// Copies <paramref name="source"/> to a new <see cref="Tensor{TTO}"/> converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
         /// </summary>
-        /// <param name="left">The first <see cref="TensorSpan{T}"/> of values to add.</param>
-        /// <param name="right">The second <see cref="TensorSpan{T}"/> of values to add.</param>
-        public static TensorSpan<T> AddInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        /// <param name="source">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<TTo> ConvertTruncating<TFrom, TTo>(Tensor<TFrom> source)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
         {
-            return TensorPrimitivesHelperT1T2(left, right, TensorPrimitives.Add, true);
+            return TensorPrimitivesHelperTFromSpanInTToSpanOut<TFrom, TTo>(source, TensorPrimitives.ConvertTruncating);
         }
+        #endregion
 
+        #region CopySign
         /// <summary>
-        /// Adds <paramref name="val"/> to each element of <paramref name="input"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// Computes the element-wise result of copying the sign from one number to another number in the specified tensors and returns a new tensor with the result.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> of values to add.</param>
-        /// <param name="val">The <typeparamref name="T"/> value to add to each element of <paramref name="input"/>.</param>
-        public static TensorSpan<T> Add<T>(TensorSpan<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        /// <param name="input">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="sign">The number with the associated sign.</param>
+        public static Tensor<T> CopySign<T>(Tensor<T> input, T sign)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            T[] values = new T[input.FlattenedLength];
-            TensorSpan<T> output = new TensorSpan<T>(values, 0, input.Lengths, default);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Add(span, val, ospan);
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            TensorPrimitives.CopySign(span, sign, ospan);
             return output;
         }
 
         /// <summary>
-        /// Adds <paramref name="val"/> to each element of <paramref name="input"/> in place.
+        /// Computes the element-wise result of copying the sign from one number to another number in the specified tensors in place.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> of values to add.</param>
-        /// <param name="val">The <typeparamref name="T"/> value to add to each element of <paramref name="input"/>.</param>
-        public static TensorSpan<T> AddInPlace<T>(TensorSpan<T> input, T val)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        /// <param name="input">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="sign">The number with the associated sign.</param>
+        public static Tensor<T> CopySignInPlace<T>(Tensor<T> input, T sign)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            TensorSpan<T> output = input;
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            TensorPrimitives.Add(span, val, ospan);
-            return output;
+            Span<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            TensorPrimitives.CopySign(span, sign, span);
+            return input;
         }
 
-        #endregion
-
-        #region Norm
         /// <summary>
-        /// Takes the norm of the <see cref="Tensor{T}"/> and returns the result.
+        /// Computes the element-wise result of copying the sign from one number to another number in the specified tensors and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/> to take the norm of.</param>
-        public static T Norm<T>(Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        /// <param name="input">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="sign">The <see cref="Tensor{T}"/> with the associated signs.</param>
+        public static Tensor<T> CopySign<T>(Tensor<T> input, Tensor<T> sign)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            return TensorPrimitives.Norm(span);
+            return TensorPrimitivesHelperTwoSpanInSpanOut(input, sign, TensorPrimitives.CopySign);
         }
 
         /// <summary>
-        ///  Takes the norm of the <see cref="TensorSpan{T}"/> and returns the result.
+        /// Computes the element-wise result of copying the sign from one number to another number in the specified tensors in place.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the norm of.</param>
-        public static T Norm<T>(TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        /// <param name="input">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="sign">The <see cref="Tensor{T}"/> with the associated signs.</param>
+        public static Tensor<T> CopySignInPlace<T>(Tensor<T> input, Tensor<T> sign)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            return TensorPrimitives.Norm(span);
+            return TensorPrimitivesHelperTwoSpanInSpanOut(input, sign, TensorPrimitives.CopySign, true);
         }
-
         #endregion
 
         #region Cos
@@ -2028,42 +1712,952 @@ public static T Norm<T>(TensorSpan<T> input)
         public static Tensor<T> Cos<T>(Tensor<T> input)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Cos);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cos);
         }
 
         /// <summary>
-        /// Takes the cosine of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// Takes the cosine of each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the cosine of.</param>
-        public static TensorSpan<T> Cos<T>(TensorSpan<T> input)
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the cosine of.</param>
+        public static Tensor<T> CosInPlace<T>(Tensor<T> input)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Cos);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cos, true);
         }
+        #endregion
 
+        #region Cosh
         /// <summary>
-        /// Takes the cosine of each element of the <see cref="Tensor{T}"/> in place.
+        /// Takes the hyperbolic cosine of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
         /// <param name="input">The <see cref="Tensor{T}"/> to take the cosine of.</param>
-        public static Tensor<T> CosInPlace<T>(Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        public static Tensor<T> Cosh<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Cos, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cosh);
         }
 
         /// <summary>
-        /// Takes the cosine of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// Takes the hyperbolic cosine of each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the cosine of.</param>
-        public static TensorSpan<T> CosInPlace<T>(TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the cosine of.</param>
+        public static Tensor<T> CoshInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Cos, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cosh, true);
         }
-
         #endregion
 
-        #region Sin
+        #region CosineSimilarity
+        /// <summary>
+        /// Compute cosine similarity between <paramref name="left"/> and <paramref name="right"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="Tensor{T}"/></param>
+        /// <param name="right">The second <see cref="Tensor{T}"/></param>
+        public static Tensor<T> CosineSimilarity<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            if (left.Rank != 2)
+                ThrowHelper.ThrowArgument_2DTensorRequired(nameof(left));
+
+            if (right.Rank != 2)
+                ThrowHelper.ThrowArgument_2DTensorRequired(nameof(right));
+
+            if (left.Lengths[1] != right.Lengths[1])
+                ThrowHelper.ThrowArgument_IncompatibleDimensions(left.Lengths[1], right.Lengths[1]);
+
+            nint dim1 = left.Lengths[0];
+            nint dim2 = right.Lengths[0];
+
+            T[] values = new T[dim1 * dim2];
+
+            scoped Span<nint> leftIndexes = stackalloc nint[2];
+            scoped Span<nint> rightIndexes = stackalloc nint[2];
+
+            int outputOffset = 0;
+
+            ReadOnlySpan<T> lspan;
+            ReadOnlySpan<T> rspan;
+            int rowLength = (int)left.Lengths[1];
+            for (int i = 0; i < dim1; i++)
+            {
+                for (int j = 0; j < dim2; j++)
+                {
+                    lspan = MemoryMarshal.CreateSpan(ref left[leftIndexes], rowLength);
+                    rspan = MemoryMarshal.CreateSpan(ref right[rightIndexes], rowLength);
+                    values[outputOffset++] = TensorPrimitives.CosineSimilarity(lspan, rspan);
+                    rightIndexes[0]++;
+                }
+                rightIndexes[0] = 0;
+                leftIndexes[0]++;
+            }
+
+            return Tensor.Create<T>(values, [dim1, dim2]);
+
+        }
+        #endregion
+
+        #region CosPi
+        /// <summary>Computes the element-wise cosine of the value in the specified tensor that has been multiplied by Pi and returns a new <see cref="Tensor{T}"/> with the results.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/></param>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><typeparamref name="T"/>.CosPi(<paramref name="input" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi/180 to convert degrees to radians.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static Tensor<T> CosPi<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.CosPi);
+        }
+
+        /// <summary>Computes the element-wise cosine of the value in the specified tensor that has been multiplied by Pi in place.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/></param>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><typeparamref name="T"/>.CosPi(<paramref name="input" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi/180 to convert degrees to radians.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static Tensor<T> CosPiInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.CosPi, true);
+        }
+        #endregion
+
+        #region DegreesToRadians
+        /// <summary>
+        /// Computes the element-wise conversion of each number of degrees in the specified tensor to radians and returns a new tensor with the results.
+        /// </summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> DegreesToRadians<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.DegreesToRadians);
+        }
+
+        /// <summary>
+        /// Computes the element-wise conversion of each number of degrees in the specified tensor to radians in place.
+        /// </summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> DegreesToRadiansInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.DegreesToRadians, true);
+        }
+        #endregion
+
+        #region Distance
+        /// <summary>
+        /// Computes the distance between two points, specified as non-empty, equal-length tensors of numbers, in Euclidean space.
+        /// </summary>
+        /// <param name="left">The input <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The input <see cref="Tensor{T}"/>.</param>
+        public static T Distance<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInTOut(left, right, TensorPrimitives.Distance);
+        }
+
+        #endregion
+
+        #region Divide
+        /// <summary>
+        /// Divides each element of <paramref name="input"/> by <paramref name="val"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="val">The divisor</param>
+        public static Tensor<T> Divide<T>(Tensor<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            TensorPrimitives.Divide(span, val, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Divides each element of <paramref name="input"/> by <paramref name="val"/> in place.
+        /// </summary>
+        /// <param name="input">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="val">The divisor.</param>
+        public static Tensor<T> DivideInPlace<T>(Tensor<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = input;
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            TensorPrimitives.Divide(span, val, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Divides <paramref name="val"/> by each element of <paramref name="input"/> and returns a new <see cref="Tensor{T}"/> with the result."/>
+        /// </summary>
+        /// <param name="val">The value to be divided.</param>
+        /// <param name="input">The <see cref="Tensor{T}"/> divisor.</param>
+        public static Tensor<T> Divide<T>(T val, Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            TensorPrimitives.Divide(val, span, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Divides <paramref name="val"/> by each element of <paramref name="input"/> in place.
+        /// </summary>
+        /// <param name="val">The value to be divided.</param>
+        /// <param name="input">The <see cref="Tensor{T}"/> divisor.</param>
+        public static Tensor<T> DivideInPlace<T>(T val, Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = input;
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            TensorPrimitives.Divide(val, span, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Divides each element of <paramref name="left"/> by its corresponding element in <paramref name="right"/> and returns
+        /// a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="left">The <see cref="Tensor{T}"/> to be divided.</param>
+        /// <param name="right">The <see cref="Tensor{T}"/> divisor.</param>
+        public static Tensor<T> Divide<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Divide);
+        }
+
+        /// <summary>
+        /// Divides each element of <paramref name="left"/> by its corresponding element in <paramref name="right"/> in place.
+        /// </summary>
+        /// <param name="left">The <see cref="Tensor{T}"/> to be divided.</param>
+        /// <param name="right">The <see cref="Tensor{T}"/> divisor.</param>
+        public static Tensor<T> DivideInPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Divide, true);
+        }
+        #endregion
+
+        #region Dot
+        /// <summary>
+        /// Computes the dot product of two tensors containing numbers.
+        /// </summary>
+        /// <param name="left">The input <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The input <see cref="Tensor{T}"/>.</param>
+        public static T Dot<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplicativeIdentity<T, T>, IMultiplyOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInTOut(left, right, TensorPrimitives.Dot);
+        }
+
+        #endregion
+
+        #region Exp
+        /// <summary>
+        /// Computes the element-wise result of raising <c>e</c> to the single-precision floating-point number powers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Exp<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp);
+        }
+
+        /// <summary>
+        /// Computes the element-wise result of raising <c>e</c> to the single-precision floating-point number powers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> ExpInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp, true);
+        }
+        #endregion
+
+        #region Exp10
+        /// <summary>
+        /// Computes the element-wise result of raising 10 to the number powers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Exp10<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp10);
+        }
+
+        /// <summary>
+        /// Computes the element-wise result of raising 10 to the number powers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Exp10InPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp10, true);
+        }
+        #endregion
+
+        #region Exp10M1
+        /// <summary>Computes the element-wise result of raising 10 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Exp10M1<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp10M1);
+        }
+
+        /// <summary>Computes the element-wise result of raising 10 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Exp10M1InPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp10M1, true);
+        }
+        #endregion
+
+        #region Exp2
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Exp2<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp2);
+        }
+
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Exp2InPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp2, true);
+        }
+        #endregion
+
+        #region Exp2M1
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Exp2M1<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp2M1);
+        }
+
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Exp2M1InPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp2M1, true);
+        }
+        #endregion
+
+        #region ExpM1
+        /// <summary>Computes the element-wise result of raising <c>e</c> to the number powers in the specified tensor, minus 1.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> ExpM1<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.ExpM1);
+        }
+
+        /// <summary>Computes the element-wise result of raising <c>e</c> to the number powers in the specified tensor, minus 1.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> ExpM1InPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.ExpM1, true);
+        }
+        #endregion
+
+        #region Floor
+        /// <summary>Computes the element-wise floor of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Floor<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Floor);
+        }
+
+        /// <summary>Computes the element-wise floor of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> FloorInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Floor, true);
+        }
+        #endregion
+
+        #region Hypotenuse
+        /// <summary>
+        /// Computes the element-wise hypotenuse given values from two tensors representing the lengths of the shorter sides in a right-angled triangle.
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// </summary>
+        /// <param name="left">Left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">Right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Hypotenuse<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Hypot);
+        }
+
+        /// <summary>
+        /// Computes the element-wise hypotenuse given values from two tensors representing the lengths of the shorter sides in a right-angled triangle.
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// </summary>
+        /// <param name="left">Left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">Right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> HypotenuseInPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Hypot, true);
+        }
+        #endregion
+
+        #region Ieee754Remainder
+        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// <param name="left">Left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">Right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Ieee754Remainder<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Ieee754Remainder);
+        }
+
+        /// <summary>
+        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// </summary>
+        /// <param name="left">Left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">Right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Ieee754RemainderInPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Ieee754Remainder, true);
+        }
+        #endregion
+
+        #region ILogB
+        /// <summary>Computes the element-wise floor of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<int> ILogB<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
+        {
+            return TensorPrimitivesHelperSpanInIntSpanOut(input, TensorPrimitives.ILogB);
+        }
+        #endregion
+
+        #region IndexOfMax
+        /// <summary>Searches for the index of the largest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static int IndexOfMax<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            return TensorPrimitives.IndexOfMax(span);
+        }
+        #endregion
+
+        #region IndexOfMaxMagnitude
+        /// <summary>Searches for the index of the number with the largest magnitude in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static int IndexOfMaxMagnitude<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            return TensorPrimitives.IndexOfMaxMagnitude(span);
+        }
+        #endregion
+
+        #region IndexOfMin
+        /// <summary>Searches for the index of the smallest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static int IndexOfMin<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            return TensorPrimitives.IndexOfMin(span);
+        }
+        #endregion
+
+        #region IndexOfMinMagnitude
+        /// <summary>
+        /// Searches for the index of the number with the smallest magnitude in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static int IndexOfMinMagnitude<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            return TensorPrimitives.IndexOfMinMagnitude(span);
+        }
+        #endregion
+
+        #region LeadingZeroCount
+        /// <summary>
+        /// Computes the element-wise leading zero count of numbers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> LeadingZeroCount<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.LeadingZeroCount);
+        }
+
+        /// <summary>
+        /// Computes the element-wise leading zero count of numbers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> LeadingZeroCountInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.LeadingZeroCount, true);
+        }
+        #endregion
+
+        #region Log
+        /// <summary>
+        /// Takes the natural logarithm of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the natural logarithm of.</param>
+        public static Tensor<T> Log<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log);
+        }
+
+        /// <summary>
+        /// Takes the natural logarithm of each element of the <see cref="Tensor{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the natural logarithm of.</param>
+        public static Tensor<T> LogInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log, true);
+        }
+        #endregion
+
+        #region Log10
+        /// <summary>
+        /// Takes the base 10 logarithm of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 10 logarithm of.</param>
+        public static Tensor<T> Log10<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log10);
+        }
+
+        /// <summary>
+        /// Takes the base 10 logarithm of each element of the <see cref="Tensor{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 10 logarithm of.</param>
+        public static Tensor<T> Log10InPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log10, true);
+        }
+        #endregion
+
+        #region Log10P1
+        /// <summary>
+        /// Takes the base 10 logarithm plus 1 of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 10 logarithm of.</param>
+        public static Tensor<T> Log10P1<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log10P1);
+        }
+
+        /// <summary>
+        /// Takes the base 10 logarithm plus 1 of each element of the <see cref="Tensor{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 10 logarithm of.</param>
+        public static Tensor<T> Log10P1InPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log10P1, true);
+        }
+        #endregion
+
+        #region Log2
+        /// <summary>
+        /// Takes the base 2 logarithm of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 2 logarithm of.</param>
+        public static Tensor<T> Log2<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log2);
+        }
+
+        /// <summary>
+        /// Takes the base 2 logarithm of each element of the <see cref="Tensor{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 2 logarithm of.</param>
+        public static Tensor<T> Log2InPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log2, true);
+        }
+
+        #endregion
+
+        #region Log2P1
+        /// <summary>
+        /// Takes the base 2 logarithm plus 1 of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 2 logarithm of.</param>
+        public static Tensor<T> Log2P1<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log2P1);
+        }
+
+        /// <summary>
+        /// Takes the base 2 logarithm plus 1 of each element of the <see cref="Tensor{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 2 logarithm of.</param>
+        public static Tensor<T> Log2P1InPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log2P1, true);
+        }
+        #endregion
+
+        #region LogP1
+        /// <summary>
+        /// Takes the natural logarithm plus 1 of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the natural logarithm of.</param>
+        public static Tensor<T> LogP1<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.LogP1);
+        }
+
+        /// <summary>
+        /// Takes the natural logarithm plus 1 of each element of the <see cref="Tensor{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the natural logarithm of.</param>
+        public static Tensor<T> LogP1InPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.LogP1, true);
+        }
+        #endregion
+
+        #region Max
+        /// <summary>Searches for the largest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>..</param>
+        public static T Max<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.Max);
+        }
+        #endregion
+
+        #region MaxMagnitude
+        /// <summary>Searches for the number with the largest magnitude in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>..</param>
+        public static T MaxMagnitude<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.MaxMagnitude);
+        }
+        #endregion
+
+        #region MaxNumber
+        /// <summary>Searches for the largest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>..</param>
+        public static T MaxNumber<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.MaxNumber);
+        }
+        #endregion
+
+        #region Min
+        /// <summary>Searches for the smallest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static T Min<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.Min);
+        }
+        #endregion
+
+        #region MinMagnitude
+        /// <summary>Searches for the number with the smallest magnitude in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static T MinMagnitude<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.MinMagnitude);
+        }
+        #endregion
+
+        #region MinNumber
+        /// <summary>Searches for the smallest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>..</param>
+        public static T MinNumber<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.MinNumber);
+        }
+        #endregion
+
+        #region Multiply
+        /// <summary>
+        /// Multiplies each element of <paramref name="input"/> with <paramref name="val"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">Input <see cref="Tensor{T}"/></param>
+        /// <param name="val"><typeparamref name="T"/> value to multiply by.</param>
+        public static Tensor<T> Multiply<T>(Tensor<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            TensorPrimitives.Multiply(span, val, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Multiplies each element of <paramref name="input"/> with <paramref name="val"/> in place.
+        /// </summary>
+        /// <param name="input">Input <see cref="Tensor{T}"/></param>
+        /// <param name="val"><typeparamref name="T"/> value to multiply by.</param>
+        public static Tensor<T> MultiplyInPlace<T>(Tensor<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = input;
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            TensorPrimitives.Multiply(span, val, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Multiplies each element of <paramref name="left"/> with <paramref name="right"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// </summary>
+        /// <param name="left">Left <see cref="Tensor{T}"/> for multiplication.</param>
+        /// <param name="right">Right <see cref="Tensor{T}"/> for multiplication.</param>
+        public static Tensor<T> Multiply<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Multiply);
+        }
+
+        /// <summary>
+        /// Multiplies each element of <paramref name="left"/> with <paramref name="right"/> in place.
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// </summary>
+        /// <param name="left">Left <see cref="Tensor{T}"/> for multiplication.</param>
+        /// <param name="right">Right <see cref="Tensor{T}"/> for multiplication.</param>
+        public static Tensor<T> MultiplyInPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Multiply, true);
+        }
+        #endregion
+
+        #region Negate
+        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/></param>
+        public static Tensor<T> Negate<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IUnaryNegationOperators<T, T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Negate);
+        }
+
+        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/></param>
+        public static Tensor<T> NegateInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IUnaryNegationOperators<T, T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Negate, true);
+        }
+        #endregion
+
+        #region Norm
+        /// <summary>
+        /// Takes the norm of the <see cref="Tensor{T}"/> and returns the result.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the norm of.</param>
+        public static T Norm<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.Norm);
+        }
+        #endregion
+
+        #region OnesComplement
+        /// <summary>Computes the element-wise one's complement of numbers in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/></param>
+        public static Tensor<T> OnesComplement<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.OnesComplement);
+        }
+
+        /// <summary>Computes the element-wise one's complement of numbers in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/></param>
+        public static Tensor<T> OnesComplementInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.OnesComplement, true);
+        }
+        #endregion
+
+        #region PopCount
+        /// <summary>Computes the element-wise population count of numbers in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/></param>
+        public static Tensor<T> PopCount<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.PopCount);
+        }
+
+        /// <summary>Computes the element-wise population count of numbers in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/></param>
+        public static Tensor<T> PopCountInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.PopCount, true);
+        }
+        #endregion
+
+        #region Pow
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
+        /// <param name="left">The input <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The second input <see cref="Tensor{T}"/></param>
+        public static Tensor<T> Pow<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IPowerFunctions<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Pow);
+        }
+
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
+        /// <param name="left">The input <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The second input <see cref="Tensor{T}"/></param>
+        public static Tensor<T> PowInPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IPowerFunctions<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Pow, true);
+        }
+        #endregion
+
+        #region Product
+        /// <summary>Computes the product of all elements in the specified non-empty tensor of numbers.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static T Product<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplicativeIdentity<T, T>, IMultiplyOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.Product);
+        }
+        #endregion
+
+        #region RadiansToDegrees
+        /// <summary>Computes the element-wise conversion of each number of radians in the specified tensor to degrees.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> RadiansToDegrees<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.RadiansToDegrees);
+        }
+
+        /// <summary>Computes the element-wise conversion of each number of radians in the specified tensor to degrees.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> RadiansToDegreesInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.RadiansToDegrees, true);
+        }
+        #endregion
+
+        #region Reciprocal
+        /// <summary>Computes the element-wise reciprocal of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Reciprocal<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Reciprocal);
+        }
+
+        /// <summary>Computes the element-wise reciprocal of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> ReciprocalInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Reciprocal, true);
+        }
+        #endregion
+
+        #region Round
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Round<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Round);
+        }
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> RoundInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Round, true);
+        }
+        #endregion
+
+        #region Sigmoid
+        /// <summary>Computes the element-wise sigmoid function on the specified non-empty tensor of numbers.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Sigmoid<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sigmoid);
+        }
+
+        /// <summary>Computes the element-wise sigmoid function on the specified non-empty tensor of numbers.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> SigmoidInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sigmoid, true);
+        }
+        #endregion
+
+        #region Sin
         /// <summary>
         /// Takes the sin of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
@@ -2071,39 +2665,72 @@ public static TensorSpan<T> CosInPlace<T>(TensorSpan<T> input)
         public static Tensor<T> Sin<T>(Tensor<T> input)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Sin);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sin);
+        }
+
+        /// <summary>
+        /// Takes the sin of each element of the <see cref="Tensor{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> SinInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sin, true);
+        }
+        #endregion
+
+        #region Sinh
+        /// <summary>Computes the element-wise hyperbolic sine of each radian angle in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> Sinh<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sinh);
+        }
+
+        /// <summary>Computes the element-wise hyperbolic sine of each radian angle in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> SinhInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sinh, true);
         }
+        #endregion
 
-        /// <summary>
-        /// Takes the sin of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
-        public static TensorSpan<T> Sin<T>(TensorSpan<T> input)
+        #region SinPi
+        /// <summary>Computes the element-wise sine of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> SinPi<T>(Tensor<T> input)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Sin);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.SinPi);
         }
 
-        /// <summary>
-        /// Takes the sin of each element of the <see cref="Tensor{T}"/> in place.
-        /// </summary>
+        /// <summary>Computes the element-wise sine of the value in the specified tensor that has been multiplied by Pi.</summary>
         /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
-        public static Tensor<T> SinInPlace<T>(Tensor<T> input)
+        public static Tensor<T> SinPiInPlace<T>(Tensor<T> input)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Sin, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.SinPi, true);
         }
+        #endregion
 
-        /// <summary>
-        /// Takes the sin of each element of the <see cref="TensorSpan{T}"/> in place.
-        /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
-        public static TensorSpan<T> SinInPlace<T>(TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        #region SoftMax
+        /// <summary>Computes the softmax function over the specified non-empty tensor of numbers.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> SoftMax<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Sin, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.SoftMax);
         }
 
+        /// <summary>Computes the softmax function over the specified non-empty tensor of numbers.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> SoftMaxInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.SoftMax, true);
+        }
         #endregion
 
         #region Sqrt
@@ -2114,177 +2741,273 @@ public static TensorSpan<T> SinInPlace<T>(TensorSpan<T> input)
         public static Tensor<T> Sqrt<T>(Tensor<T> input)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Sqrt);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sqrt);
         }
 
         /// <summary>
-        /// Takes the square root of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// Takes the square root of each element of the <see cref="Tensor{T}"/> in place.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the square root of.</param>
-        public static TensorSpan<T> Sqrt<T>(TensorSpan<T> input)
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the square root of.</param>
+        public static Tensor<T> SqrtInPlace<T>(Tensor<T> input)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Sqrt);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sqrt, true);
         }
+        #endregion
 
+        #region Subtract
         /// <summary>
-        /// Takes the square root of each element of the <see cref="Tensor{T}"/> in place.
+        /// Subtracts <paramref name="val"/> from each element of <paramref name="input"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/> to take the square root of.</param>
-        public static Tensor<T> SqrtInPlace<T>(Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        /// <param name="input">The <see cref="Tensor{T}"/>.</param>
+        /// <param name="val">The <typeparamref name="T"/> to subtract.</param>
+        public static Tensor<T> Subtract<T>(Tensor<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Sqrt, true);
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            TensorPrimitives.Subtract(span, val, ospan);
+            return output;
         }
 
         /// <summary>
-        /// Takes the square root of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// Subtracts <paramref name="val"/> from each element of <paramref name="input"/> in place.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the square root of.</param>
-        public static TensorSpan<T> SqrtInPlace<T>(TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        /// <param name="input">The <see cref="Tensor{T}"/>.</param>
+        /// <param name="val">The <typeparamref name="T"/> to subtract.</param>
+        public static Tensor<T> SubtractInPlace<T>(Tensor<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Sqrt, true);
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = input;
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            TensorPrimitives.Subtract(span, val, ospan);
+            return output;
         }
 
-        #endregion
-
-        #region Log
         /// <summary>
-        /// Takes the natural logarithm of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// Subtracts each element of <paramref name="input"/> from <paramref name="val"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/> to take the natural logarithm of.</param>
-        public static Tensor<T> Log<T>(Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        /// <param name="val">The <typeparamref name="T"/> to be subtracted from.</param>
+        /// <param name="input">The <see cref="Tensor{T}"/> of values to subtract.</param>
+        public static Tensor<T> Subtract<T>(T val, Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log);
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            TensorPrimitives.Subtract(val, span, ospan);
+            return output;
         }
 
         /// <summary>
-        /// Takes the natural logarithm of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// Subtracts each element of <paramref name="input"/> from <paramref name="val"/> in place.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the natural logarithm of.</param>
-        public static TensorSpan<T> Log<T>(TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        /// <param name="val">The <typeparamref name="T"/> to be subtracted from.</param>
+        /// <param name="input">The <see cref="Tensor{T}"/> of values to subtract.</param>
+        public static Tensor<T> SubtractInPlace<T>(T val, Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log);
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = input;
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            TensorPrimitives.Subtract(val, span, ospan);
+            return output;
         }
 
         /// <summary>
-        /// Takes the natural logarithm of each element of the <see cref="Tensor{T}"/> in place.
+        /// Subtracts each element of <paramref name="left"/> from <paramref name="right"/> and returns a new <see cref="Tensor{T}"/> with the result.
         /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/> to take the natural logarithm of.</param>
-        public static Tensor<T> LogInPlace<T>(Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        /// <param name="left">The <see cref="Tensor{T}"/> with values to be subtracted from.</param>
+        /// <param name="right">The <see cref="Tensor{T}"/> with values to subtract.</param>
+        public static Tensor<T> Subtract<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log, true);
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Subtract);
         }
 
         /// <summary>
-        /// Takes the natural logarithm of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// Subtracts each element of <paramref name="left"/> from <paramref name="right"/> in place.
         /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the natural logarithm of.</param>
-        public static TensorSpan<T> LogInPlace<T>(TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        /// <param name="left">The <see cref="Tensor{T}"/> with values to be subtracted from.</param>
+        /// <param name="right">The <see cref="Tensor{T}"/> with values to subtract.</param>
+        public static Tensor<T> SubtractInPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log, true);
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Subtract, true);
         }
-
         #endregion
 
-        #region Log10
+        #region Sum
+
         /// <summary>
-        /// Takes the base 10 logarithm of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// Sums all the elements of the <see cref="Tensor{T}"/> and returns the result.
         /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 10 logarithm of.</param>
-        public static Tensor<T> Log10<T>(Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        /// <param name="input">The <see cref="Tensor{T}"/> to sum.</param>
+        public static T Sum<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log10);
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            return TensorPrimitives.Sum(span);
         }
 
-        /// <summary>
-        /// Takes the base 10 logarithm of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 10 logarithm of.</param>
-        public static TensorSpan<T> Log10<T>(TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        #endregion
+
+        #region Tan
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> Tan<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log10);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Tan);
         }
 
-        /// <summary>
-        /// Takes the base 10 logarithm of each element of the <see cref="Tensor{T}"/> in place.
-        /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 10 logarithm of.</param>
-        public static Tensor<T> Log10InPlace<T>(Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> TanInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log10, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Tan, true);
         }
+        #endregion
 
-        /// <summary>
-        /// Takes the base 10 logarithm of each element of the <see cref="TensorSpan{T}"/> in place.
-        /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 10 logarithm of.</param>
-        public static TensorSpan<T> Log10InPlace<T>(TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        #region Tanh
+        /// <summary>Computes the element-wise hyperbolic tangent of each radian angle in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> Tanh<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Tanh);
+        }
+
+        /// <summary>Computes the element-wise hyperbolic tangent of each radian angle in the specified tensor.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> TanhInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log10, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Tanh, true);
         }
         #endregion
 
-        #region Log2
-        /// <summary>
-        /// Takes the base 2 logarithm of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 2 logarithm of.</param>
-        public static Tensor<T> Log2<T>(Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        #region TanPi
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> TanPi<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log2);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.TanPi);
         }
 
-        /// <summary>
-        /// Takes the base 2 logarithm of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 2 logarithm of.</param>
-        public static TensorSpan<T> Log2<T>(TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static Tensor<T> TanPiInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log2);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.TanPi, true);
         }
+        #endregion
 
-        /// <summary>
-        /// Takes the base 2 logarithm of each element of the <see cref="Tensor{T}"/> in place.
-        /// </summary>
-        /// <param name="input">The <see cref="Tensor{T}"/> to take the base 2 logarithm of.</param>
-        public static Tensor<T> Log2InPlace<T>(Tensor<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        #region TrailingZeroCount
+        /// <summary>Computes the element-wise trailing zero count of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> TrailingZeroCount<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log2, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.TrailingZeroCount);
         }
 
-        /// <summary>
-        /// Takes the base 2 logarithm of each element of the <see cref="TensorSpan{T}"/> in place.
-        /// </summary>
-        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 2 logarithm of.</param>
-        public static TensorSpan<T> Log2InPlace<T>(TensorSpan<T> input)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        /// <summary>Computes the element-wise trailing zero count of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> TrailingZeroCountInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.TrailingZeroCount, true);
+        }
+        #endregion
+
+        #region Truncate
+        /// <summary>Computes the element-wise truncation of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Truncate<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Truncate);
+        }
+
+        /// <summary>Computes the element-wise truncation of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> TruncateInPlace<T>(Tensor<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
         {
-            return TensorPrimitivesHelperT1(input, TensorPrimitives.Log2, true);
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Truncate, true);
+        }
+        #endregion
+
+        #region Xor
+        /// <summary>Computes the element-wise XOR of numbers in the specified tensors.</summary>
+        /// <param name="left">The left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Xor<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Xor);
         }
 
+        /// <summary>Computes the element-wise XOR of numbers in the specified tensors.</summary>
+        /// <param name="left">The left <see cref="Tensor{T}"/>.</param>
+        /// <param name="right">The right <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> XorInPlace<T>(Tensor<T> left, Tensor<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Xor, true);
+        }
         #endregion
 
         #region TensorPrimitivesHelpers
-        private delegate void PerformCalculationT1<T>(ReadOnlySpan<T> input, Span<T> output)
+        private delegate void PerformCalculationTFromSpanInTToSpanOut<TFrom, TTo>(ReadOnlySpan<TFrom> input, Span<TTo> output)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>;
+
+        private delegate void PerformCalculationSpanInTInSpanOut<T>(ReadOnlySpan<T> input, T value, Span<T> output)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
+
+        private delegate void PerformCalculationSpanInSpanOut<T>(ReadOnlySpan<T> input, Span<T> output)
+             where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
+
+        private delegate void PerformCalculationSpanInIntSpanOut<T>(ReadOnlySpan<T> input, Span<int> output)
              where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
 
-        private delegate void PerformCalculationT1T2<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo, Span<T> output)
+        private delegate T PerformCalculationTwoSpanInTOut<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
+
+        private delegate T PerformCalculationSpanInTOut<T>(ReadOnlySpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
+
+        private delegate void PerformCalculationTwoSpanInSpanOut<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo, Span<T> output)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
 
-        private static Tensor<T> TensorPrimitivesHelperT1<T>(Tensor<T> input, PerformCalculationT1<T> performCalculation, bool inPlace = false)
+        private static Tensor<T> TensorPrimitivesHelperSpanInTInSpanOut<T>(Tensor<T> input, T value, PerformCalculationSpanInTInSpanOut<T> performCalculation, bool inPlace = false)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<T> output = inPlace ? input : Create<T>(input.Lengths, input.IsPinned);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            performCalculation(span, value, ospan);
+            return output;
+        }
+
+        private static Tensor<int> TensorPrimitivesHelperSpanInIntSpanOut<T>(Tensor<T> input, PerformCalculationSpanInIntSpanOut<T> performCalculation)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<int> output = Create<int>(input.Lengths, input.IsPinned);
+            Span<int> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
+            performCalculation(span, ospan);
+            return output;
+        }
+
+        private static Tensor<T> TensorPrimitivesHelperSpanInSpanOut<T>(Tensor<T> input, PerformCalculationSpanInSpanOut<T> performCalculation, bool inPlace = false)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>
         {
             ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
@@ -2294,20 +3017,28 @@ private static Tensor<T> TensorPrimitivesHelperT1<T>(Tensor<T> input, PerformCal
             return output;
         }
 
-        private static TensorSpan<T> TensorPrimitivesHelperT1<T>(TensorSpan<T> input, PerformCalculationT1<T> performCalculation, bool inPlace = false)
+        private static T TensorPrimitivesHelperSpanInTOut<T>(Tensor<T> input, PerformCalculationSpanInTOut<T> performCalculation)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>
         {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-            TensorSpan<T> output = inPlace ? input : new TensorSpan<T>(new T[input.FlattenedLength], 0, input.Lengths, input.Strides);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            return performCalculation(span);
+        }
+
+        private static Tensor<TTo> TensorPrimitivesHelperTFromSpanInTToSpanOut<TFrom, TTo>(Tensor<TFrom> input, PerformCalculationTFromSpanInTToSpanOut<TFrom, TTo> performCalculation)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            ReadOnlySpan<TFrom> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
+            Tensor<TTo> output = Create<TTo>(input.Lengths, input.IsPinned);
+            Span<TTo> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
             performCalculation(span, ospan);
             return output;
         }
 
-        private static Tensor<T> TensorPrimitivesHelperT1T2<T>(Tensor<T> left, Tensor<T> right, PerformCalculationT1T2<T> performCalculation, bool inPlace = false)
+        private static Tensor<T> TensorPrimitivesHelperTwoSpanInSpanOut<T>(Tensor<T> left, Tensor<T> right, PerformCalculationTwoSpanInSpanOut<T> performCalculation, bool inPlace = false)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>
         {
-            if (inPlace && left.Lengths != right.Lengths)
+            if (inPlace && !left.Lengths.SequenceEqual(right.Lengths))
                 ThrowHelper.ThrowArgument_InPlaceInvalidShape();
 
             Tensor<T> output;
@@ -2410,37 +3141,15 @@ private static Tensor<T> TensorPrimitivesHelperT1T2<T>(Tensor<T> left, Tensor<T>
             return output;
         }
 
-        private static TensorSpan<T> TensorPrimitivesHelperT1T2<T>(TensorSpan<T> left, TensorSpan<T> right, PerformCalculationT1T2<T> performCalculation, bool inPlace = false)
+        private static T TensorPrimitivesHelperTwoSpanInTOut<T>(Tensor<T> left, Tensor<T> right, PerformCalculationTwoSpanInTOut<T> performCalculation)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>
         {
-            if (inPlace && left.Lengths != right.Lengths)
-                ThrowHelper.ThrowArgument_InPlaceInvalidShape();
-
-            //ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref tensor._reference, (int)tensor.FlattenedLength);
-            //ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref right._reference, (int)right.FlattenedLength);
-            //TensorSpan<T> output = inPlace ? tensor : Create<T>(tensor.IsPinned, tensor.Lengths);
-            //Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-            //performCalculation(span, rspan, ospan);
-            //return output;
-
-            TensorSpan<T> output;
-            if (inPlace)
-            {
-                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref left._reference, (int)left.FlattenedLength);
-                ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref right._reference, (int)right.FlattenedLength);
-                output = left;
-                Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-                performCalculation(span, rspan, ospan);
-            }
             // If not in place but sizes are the same.
-            else if (left.Lengths.SequenceEqual(right.Lengths))
+            if (left.Lengths.SequenceEqual(right.Lengths))
             {
-                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref left._reference, (int)left.FlattenedLength);
-                ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref right._reference, (int)right.FlattenedLength);
-                output = new TensorSpan<T>(new T[left.FlattenedLength], 0, left.Lengths, left.Strides);
-                Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
-                performCalculation(span, rspan, ospan);
-                return output;
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref left.AsTensorSpan()._reference, (int)left.FlattenedLength);
+                ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref right.AsTensorSpan()._reference, (int)right.FlattenedLength);
+                return performCalculation(span, rspan);
             }
             // Not in place and broadcasting needs to happen.
             else
@@ -2448,78 +3157,15 @@ private static TensorSpan<T> TensorPrimitivesHelperT1T2<T>(TensorSpan<T> left, T
                 // Have a couple different possible cases here.
                 // 1 - Both tensors have row contiguous memory (i.e. a 1x5 being broadcast to a 5x5)
                 // 2 - One tensor has row contiguous memory and the right has column contiguous memory (i.e. a 1x5 and a 5x1)
+                // Because we are returning a single T though we need to actual realize the broadcasts at this point to perform the calculations.
 
-                nint[] newSize = TensorHelpers.GetSmallestBroadcastableSize(left.Lengths, right.Lengths);
-
-                TensorSpan<T> broadcastedLeft = Tensor.BroadcastTo(left, newSize);
-                TensorSpan<T> broadcastedRight = Tensor.BroadcastTo(right, newSize);
-
-                output = new TensorSpan<T>(new T[TensorSpanHelpers.CalculateTotalLength(newSize)], newSize, default);
-                nint rowLength = newSize[^1];
-                Span<T> ospan;
-                Span<T> ispan;
-                Span<T> buffer = new T[rowLength];
-
-                scoped Span<nint> curIndex;
-                nint[]? curIndexArray;
-                if (newSize.Length > 6)
-                {
-                    curIndexArray = ArrayPool<nint>.Shared.Rent(newSize.Length);
-                    curIndex = curIndexArray;
-                }
-                else
-                {
-                    curIndexArray = null;
-                    curIndex = stackalloc nint[newSize.Length];
-                }
-
-                int outputOffset = 0;
-                // ADD IN CASE WHERE NEITHER ARE ROW CONTIGUOUS
-                // tensor not row contiguous
-                if (broadcastedLeft.Strides[^1] == 0)
-                {
-                    while (outputOffset < output.FlattenedLength)
-                    {
-                        ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref output._reference, outputOffset), (int)rowLength);
-                        buffer.Fill(broadcastedLeft[curIndex]);
-                        ispan = MemoryMarshal.CreateSpan(ref broadcastedRight[curIndex], (int)rowLength);
-                        performCalculation(buffer, ispan, ospan);
-                        outputOffset += (int)rowLength;
-                        TensorSpanHelpers.AdjustIndexes(broadcastedLeft.Rank - 2, 1, curIndex, broadcastedLeft.Lengths);
-                    }
-                }
-                // right not row contiguous
-                else if (broadcastedRight.Strides[^1] == 0)
-                {
-                    while (outputOffset < output.FlattenedLength)
-                    {
-                        ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref output._reference, outputOffset), (int)rowLength);
-                        buffer.Fill(broadcastedRight[curIndex]);
-                        ispan = MemoryMarshal.CreateSpan(ref broadcastedLeft[curIndex], (int)rowLength);
-                        performCalculation(ispan, buffer, ospan);
-                        outputOffset += (int)rowLength;
-                        TensorSpanHelpers.AdjustIndexes(broadcastedLeft.Rank - 2, 1, curIndex, broadcastedLeft.Lengths);
-                    }
-                }
-                // both row contiguous
-                else
-                {
-                    Span<T> rspan;
-                    while (outputOffset < output.FlattenedLength)
-                    {
-                        ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref output._reference, outputOffset), (int)rowLength);
-                        ispan = MemoryMarshal.CreateSpan(ref broadcastedLeft[curIndex], (int)rowLength);
-                        rspan = MemoryMarshal.CreateSpan(ref broadcastedRight[curIndex], (int)rowLength);
-                        performCalculation(ispan, rspan, ospan);
-                        outputOffset += (int)rowLength;
-                        TensorSpanHelpers.AdjustIndexes(broadcastedLeft.Rank - 2, 1, curIndex, broadcastedLeft.Lengths);
-                    }
-                }
+                var broadcastedLeft = Tensor.Broadcast(left, right);
+                var broadcastedRight = Tensor.Broadcast(right, left);
 
-                if (curIndexArray != null)
-                    ArrayPool<nint>.Shared.Return(curIndexArray);
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref broadcastedLeft.AsTensorSpan()._reference, (int)broadcastedLeft.FlattenedLength);
+                ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref broadcastedRight.AsTensorSpan()._reference, (int)broadcastedRight.FlattenedLength);
+                return performCalculation(span, rspan);
             }
-            return output;
         }
         #endregion
         #endregion
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorHelpers.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorHelpers.cs
index 585bc4e344140..0fd46eb8d58f5 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorHelpers.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorHelpers.cs
@@ -2,20 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Data;
-using System.Diagnostics.CodeAnalysis;
-using System.IO;
 using System.Linq;
-using System.Net.NetworkInformation;
-using System.Reflection.Metadata.Ecma335;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading.Tasks;
-using Microsoft.CSharp.RuntimeBinder;
-using Microsoft.VisualBasic;
 
 namespace System.Numerics.Tensors
 {
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.DegreesToRadians.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.DegreesToRadians.cs
index 68d7781f21cd0..27d11cf14ce72 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.DegreesToRadians.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.DegreesToRadians.cs
@@ -7,7 +7,7 @@ namespace System.Numerics.Tensors
 {
     public static partial class TensorPrimitives
     {
-        /// <summary>Computes the element-wise conversion of each number of degrees in the specified tensor to radiansx.</summary>
+        /// <summary>Computes the element-wise conversion of each number of degrees in the specified tensor to radians.</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>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Hypot.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Hypot.cs
index 30b9bc5178519..f0c46347ac244 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Hypot.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Hypot.cs
@@ -7,7 +7,7 @@ namespace System.Numerics.Tensors
 {
     public static partial class TensorPrimitives
     {
-        /// <summary>Computes the element-wise hypotensue given values from two tensors representing the lengths of the shorter sides in a right-angled triangle.</summary>
+        /// <summary>Computes the element-wise hypotenuse given values from two tensors representing the lengths of the shorter sides in a right-angled triangle.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
         /// <param name="y">The second tensor, represented as a span.</param>
         /// <param name="destination">The destination tensor, represented as a span.</param>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs
index 77c795fb8c119..b6e8826cb2556 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs
@@ -7,9 +7,6 @@
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Runtime.InteropServices.Marshalling;
-using System.Runtime.Versioning;
-using System.Text;
 using static System.Runtime.InteropServices.JavaScript.JSType;
 using EditorBrowsableAttribute = System.ComponentModel.EditorBrowsableAttribute;
 using EditorBrowsableState = System.ComponentModel.EditorBrowsableState;
@@ -46,7 +43,7 @@ public readonly ref struct TensorSpan<T>
         /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
         /// <exception cref="ArrayTypeMismatchException">Thrown when <paramref name="array"/> is covariant and array's type is not exactly T[].</exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public TensorSpan(T[]? array) : this(array, 0, [], [])
+        public TensorSpan(T[]? array) : this(array, 0, [array?.Length ?? 0], [])
         {
         }
 
@@ -84,6 +81,9 @@ public TensorSpan(T[]? array, Index startIndex, scoped ReadOnlySpan<nint> length
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public TensorSpan(T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
+            if (lengths.IsEmpty && array != null)
+                lengths = [array.Length];
+
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
             if (array == null)
             {
@@ -95,19 +95,20 @@ public TensorSpan(T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scop
             if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
                 ThrowHelper.ThrowArrayTypeMismatchException();
 
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths) : strides;
-            nint maxElements = TensorSpanHelpers.ComputeMaxElementCount(strides, lengths);
+            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
+            TensorSpanHelpers.ValidateStrides(strides, lengths);
+            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
 
             if (Environment.Is64BitProcess)
             {
                 // See comment in Span<T>.Slice for how this works.
-                if ((ulong)(uint)start + (ulong)(uint)maxElements > (ulong)(uint)array.Length)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
+                if ((ulong)(uint)start + (ulong)(uint)maxElements >= (ulong)(uint)array.Length && array.Length != 0)
+                    ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
             }
             else
             {
-                if ((uint)start > (uint)array.Length || (uint)maxElements > (uint)(array.Length - start))
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
+                if (((uint)start > (uint)array.Length || (uint)maxElements >= (uint)(array.Length - start)) && array.Length != 0)
+                    ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
             }
 
             _flattenedLength = linearLength;
@@ -134,18 +135,16 @@ public TensorSpan(Span<T> span) : this(span, [span.Length], []) { }
         /// <param name="strides">The strides for each dimension. Will be automatically calculated if not provided.</param>
         public TensorSpan(Span<T> span, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
+            if (lengths.IsEmpty)
+                lengths = [span.Length];
+
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            if (span.IsEmpty)
-            {
-                if (linearLength != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-                this = default;
-                return; // returns default
-            }
 
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths) : strides;
-            nint maxElements = TensorSpanHelpers.ComputeMaxElementCount(strides, lengths);
-            if (maxElements > span.Length)
+            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
+            TensorSpanHelpers.ValidateStrides(strides, lengths);
+
+            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
+            if (maxElements >= span.Length && span.Length != 0)
                 ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
 
             _flattenedLength = linearLength;
@@ -161,7 +160,7 @@ public TensorSpan(Span<T> span, scoped ReadOnlySpan<nint> lengths, scoped ReadOn
         /// have a rank of 1 and a length equal to the length of the provided <see cref="Array"/>.
         /// </summary>
         /// <param name="array">The target array.</param>
-        public TensorSpan(Array? array) : this(array, ReadOnlySpan<int>.Empty, [], []) { }
+        public TensorSpan(Array? array) : this(array, ReadOnlySpan<int>.Empty, array == null ? [0] : (from dim in Enumerable.Range(0, array.Rank) select (nint)array.GetLength(dim)).ToArray(), []) { }
 
         /// <summary>
         /// Creates a new <see cref="TensorSpan{T}"/> over the provided <see cref="Array"/> using the specified start offsets, lengths, and strides.
@@ -173,9 +172,11 @@ public TensorSpan(Array? array) : this(array, ReadOnlySpan<int>.Empty, [], []) {
         /// <param name="strides">The strides for each dimension. Will be automatically calculated if not provided.</param>
         public TensorSpan(Array? array, scoped ReadOnlySpan<int> start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
+            if (lengths.IsEmpty && array != null)
+                lengths = (from dim in Enumerable.Range(0, array.Rank) select (nint)array.GetLength(dim)).ToArray();
+
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths) : strides;
-            nint startOffset = TensorSpanHelpers.ComputeLinearIndex(start, strides, lengths);
+
             if (array == null)
             {
                 if (!start.IsEmpty || linearLength != 0)
@@ -186,16 +187,20 @@ public TensorSpan(Array? array, scoped ReadOnlySpan<int> start, scoped ReadOnlyS
             if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
                 ThrowHelper.ThrowArrayTypeMismatchException();
 
-            nint maxElements = TensorSpanHelpers.ComputeMaxElementCount(strides, lengths);
+            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
+            TensorSpanHelpers.ValidateStrides(strides, lengths);
+
+            nint startOffset = TensorSpanHelpers.ComputeStartOffsetSystemArray(array, start);
+            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
             if (Environment.Is64BitProcess)
             {
                 // See comment in Span<T>.Slice for how this works.
-                if ((ulong)(uint)startOffset + (ulong)(uint)maxElements > (ulong)(uint)array.Length)
+                if ((ulong)(uint)startOffset + (ulong)(uint)maxElements >= (ulong)(uint)array.Length && array.Length != 0)
                     ThrowHelper.ThrowArgumentOutOfRangeException();
             }
             else
             {
-                if ((uint)startOffset > (uint)array.Length || (uint)maxElements > (uint)(array.Length - startOffset))
+                if (((uint)startOffset > (uint)array.Length || (uint)maxElements >= (uint)(array.Length - startOffset)) && array.Length != 0)
                     ThrowHelper.ThrowArgumentOutOfRangeException();
             }
 
@@ -217,9 +222,12 @@ public TensorSpan(Array? array, scoped ReadOnlySpan<int> start, scoped ReadOnlyS
         /// <param name="strides">The strides for each dimension. Will be automatically calculated if not provided.</param>
         public TensorSpan(Array? array, scoped ReadOnlySpan<NIndex> startIndex, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
+            if (lengths.IsEmpty && array != null)
+                lengths = (from dim in Enumerable.Range(0, array.Rank) select (nint)array.GetLength(dim)).ToArray();
+
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths) : strides;
-            nint start = TensorSpanHelpers.ComputeLinearIndex(startIndex, strides, lengths);
+            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
+            TensorSpanHelpers.ValidateStrides(strides, lengths);
             if (array == null)
             {
                 if (!startIndex.IsEmpty || linearLength != 0)
@@ -230,22 +238,23 @@ public TensorSpan(Array? array, scoped ReadOnlySpan<NIndex> startIndex, scoped R
             if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
                 ThrowHelper.ThrowArrayTypeMismatchException();
 
-            nint maxElements = TensorSpanHelpers.ComputeMaxElementCount(strides, lengths);
+            nint startOffset = TensorSpanHelpers.ComputeStartOffsetSystemArray(array, startIndex);
+            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
             if (Environment.Is64BitProcess)
             {
                 // See comment in Span<T>.Slice for how this works.
-                if ((ulong)(uint)start + (ulong)(uint)maxElements > (ulong)(uint)array.Length)
+                if ((ulong)(uint)startOffset + (ulong)(uint)maxElements > (ulong)(uint)array.Length)
                     ThrowHelper.ThrowArgumentOutOfRangeException();
             }
             else
             {
-                if ((uint)start > (uint)array.Length || (uint)maxElements > (uint)(array.Length - start))
+                if ((uint)startOffset > (uint)array.Length || (uint)maxElements >= (uint)(array.Length - startOffset))
                     ThrowHelper.ThrowArgumentOutOfRangeException();
             }
 
             _flattenedLength = linearLength;
             _memoryLength = array.Length;
-            _reference = ref Unsafe.Add(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), (nint)(uint)start /* force zero-extension */);
+            _reference = ref Unsafe.Add(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), (nint)(uint)startOffset /* force zero-extension */);
 
             _lengths = lengths.ToArray();
             _strides = strides.ToArray();
@@ -280,13 +289,22 @@ public unsafe TensorSpan(T* data, nint dataLength) : this(data, dataLength, [dat
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public unsafe TensorSpan(T* data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
+            if (dataLength < 0)
+                ThrowHelper.ThrowArgumentOutOfRangeException();
+
             if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
                 ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
 
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths) : strides;
-            nint maxElements = TensorSpanHelpers.ComputeMaxElementCount(strides, lengths);
-            if (maxElements > dataLength)
+            if (lengths.IsEmpty)
+                lengths = [dataLength];
+
+            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
+
+            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
+            TensorSpanHelpers.ValidateStrides(strides, lengths);
+
+            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
+            if (maxElements >= dataLength && dataLength != 0)
                 ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
             _flattenedLength = linearLength;
             _memoryLength = dataLength;
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanDebugView.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanDebugView.cs
index 151f04fd67dd9..ab6073a52341a 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanDebugView.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanDebugView.cs
@@ -1,12 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace System.Numerics.Tensors
 {
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanExtensions.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanExtensions.cs
index 629ffb27f64da..65a0f697d9c04 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanExtensions.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanExtensions.cs
@@ -1,26 +1,45 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
-using System.Threading.Tasks;
 
 namespace System.Numerics.Tensors
 {
     public static class TensorSpan
     {
+        #region SequenceEqual
         /// <summary>
         /// Determines whether two sequences are equal by comparing the elements using IEquatable{T}.Equals(T).
         /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static unsafe bool SequenceEqual<T>(this TensorSpan<T> span, TensorSpan<T> other) where T : IEquatable<T>? => span.FlattenedLength == other.FlattenedLength && span.Lengths.SequenceEqual(other.Lengths) && TensorSpanHelpers.SequenceEqual(ref span.GetPinnableReference(), ref other.GetPinnableReference(), (nuint)span.FlattenedLength);
+        public static bool SequenceEqual<T>(this ReadOnlyTensorSpan<T> span, in ReadOnlyTensorSpan<T> other) where T : IEquatable<T>?
+        {
+            return span.FlattenedLength == other.FlattenedLength
+                && MemoryMarshal.CreateReadOnlySpan(in span.GetPinnableReference(), (int)span.FlattenedLength).SequenceEqual(MemoryMarshal.CreateReadOnlySpan(in other.GetPinnableReference(), (int)other.FlattenedLength));
+        }
 
-        // Doing a copy here for shape because otherwise I get a CS8347 about potentially exposing it beyond its lifetime. In this case that would never happen
-        // because we were always doing a copy of the shape in the constructor anyways, but I couldn't figure out another way around it.
+        /// <summary>
+        /// Determines whether two sequences are equal by comparing the elements using IEquatable{T}.Equals(T).
+        /// </summary>
+        public static bool SequenceEqual<T>(this TensorSpan<T> span, in TensorSpan<T> other) where T : IEquatable<T>?
+        {
+            return ((ReadOnlyTensorSpan<T>)span).SequenceEqual((ReadOnlyTensorSpan<T>)other);
+        }
+
+        /// <summary>
+        /// Determines whether two sequences are equal by comparing the elements using IEquatable{T}.Equals(T).
+        /// </summary>
+        public static bool SequenceEqual<T>(this TensorSpan<T> span, in ReadOnlyTensorSpan<T> other) where T : IEquatable<T>?
+        {
+            return ((ReadOnlyTensorSpan<T>)span).SequenceEqual(other);
+        }
+        #endregion
+
+        #region AsTensorSpan
         /// <summary>
         /// Extension method to more easily create a TensorSpan from an array.
         /// </summary>
@@ -28,6 +47,2388 @@ public static class TensorSpan
         /// <param name="array">The <see cref="System.Array"/> with the data</param>
         /// <param name="shape">The shape for the <see cref="TensorSpan{T}"/></param>
         /// <returns></returns>
-        public static TensorSpan<T> AsTensorSpan<T>(this T[]? array, params scoped ReadOnlySpan<nint> shape) => new(array, 0, shape, default);
+        public static TensorSpan<T> AsTensorSpan<T>(this T[]? array, params ReadOnlySpan<nint> shape) => new(array, 0, shape, default);
+        #endregion
+
+        #region ToString
+        // REVIEW: WHAT SHOULD WE NAME THIS? WHERE DO WE WANT IT TO LIVE?
+        /// <summary>
+        /// Creates a <see cref="string"/> representation of the <see cref="TensorSpan{T}"/>."/>
+        /// </summary>
+        /// <param name="span">The <see cref="TensorSpan{T}"/> you want to represent as a string.</param>
+        /// <param name="maximumLengths">Maximum Length of each dimension</param>
+        /// <returns>A <see cref="string"/> representation of the <paramref name="span"/></returns>
+        public static string ToString<T>(this TensorSpan<T> span, params ReadOnlySpan<nint> maximumLengths) => ((ReadOnlyTensorSpan<T>)span).ToString(maximumLengths);
+
+        /// <summary>
+        /// Creates a <see cref="string"/> representation of the <see cref="ReadOnlyTensorSpan{T}"/>."/>
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="span">The <see cref="ReadOnlyTensorSpan{T}"/> you want to represent as a string.</param>
+        /// <param name="maximumLengths">Maximum Length of each dimension</param>
+        public static string ToString<T>(this ReadOnlyTensorSpan<T> span, params ReadOnlySpan<nint> maximumLengths)
+        {
+            var sb = new StringBuilder();
+            scoped Span<nint> curIndexes;
+            nint[]? curIndexesArray;
+            if (span.Rank > 6)
+            {
+                curIndexesArray = ArrayPool<nint>.Shared.Rent(span.Rank);
+                curIndexes = curIndexesArray;
+            }
+            else
+            {
+                curIndexesArray = null;
+                curIndexes = stackalloc nint[span.Rank];
+            }
+
+            nint copiedValues = 0;
+
+            T[] values = new T[span.Lengths[span.Rank - 1]];
+            while (copiedValues < span._flattenedLength)
+            {
+                var sp = new ReadOnlyTensorSpan<T>(ref Unsafe.Add(ref span._reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, span.Strides, span.Lengths)), [span.Lengths[span.Rank - 1]], [1], span.Lengths[span.Rank - 1]);
+                sb.Append('{');
+                sp.FlattenTo(values);
+                sb.Append(string.Join(",", values));
+                sb.AppendLine("}");
+
+                TensorSpanHelpers.AdjustIndexes(span.Rank - 2, 1, curIndexes, span._lengths);
+                copiedValues += span.Lengths[span.Rank - 1];
+            }
+
+            if (curIndexesArray != null)
+                ArrayPool<nint>.Shared.Return(curIndexesArray);
+
+            return sb.ToString();
+        }
+        #endregion
+
+        #region Broadcast
+        /// <summary>
+        /// Broadcast the data from <paramref name="left"/> to the smallest broadcastable shape compatible with <paramref name="right"/>. Creates a new <see cref="TensorSpan{T}"/> and allocates new memory.
+        /// </summary>
+        /// <param name="left">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">Other <see cref="TensorSpan{T}"/> to make shapes broadcastable.</param>
+        public static TensorSpan<T> Broadcast<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            nint[] newSize = TensorHelpers.GetSmallestBroadcastableSize(left.Lengths, right.Lengths);
+
+            TensorSpan<T> intermediate = BroadcastTo(left, newSize);
+            T[] data = new T[intermediate.FlattenedLength];
+            intermediate.FlattenTo(data);
+            return new TensorSpan<T>(data, 0, intermediate.Lengths, []);
+        }
+
+        /// <summary>
+        /// Broadcast the data from <paramref name="input"/> to the new shape <paramref name="shape"/>. Creates a new <see cref="Tensor{T}"/> and allocates new memory.
+        /// If the shape of the <paramref name="input"/> is not compatible with the new shape, an exception is thrown.
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="shape"><see cref="ReadOnlySpan{T}"/> of the desired new shape.</param>
+        /// <exception cref="ArgumentException">Thrown when the shapes are not broadcast compatible.</exception>
+        public static TensorSpan<T> Broadcast<T>(TensorSpan<T> input, ReadOnlySpan<nint> shape)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            TensorSpan<T> intermediate = BroadcastTo(input, shape);
+            T[] data = new T[intermediate.FlattenedLength];
+            intermediate.FlattenTo(data);
+            return new TensorSpan<T>(data, 0, intermediate.Lengths, []);
+        }
+
+        // Lazy/non-copy broadcasting, internal only for now.
+        /// <summary>
+        /// Broadcast the data from <paramref name="input"/> to the new shape <paramref name="shape"/>. Creates a new <see cref="Tensor{T}"/>
+        /// but no memory is allocated. It manipulates the strides to achieve this affect.
+        /// If the shape of the <paramref name="input"/> is not compatible with the new shape, an exception is thrown.
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="shape"><see cref="ReadOnlySpan{T}"/> of the desired new shape.</param>
+        /// <exception cref="ArgumentException">Thrown when the shapes are not broadcast compatible.</exception>
+        internal static TensorSpan<T> BroadcastTo<T>(TensorSpan<T> input, ReadOnlySpan<nint> shape)
+        where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            if (input.Lengths.SequenceEqual(shape))
+                return new TensorSpan<T>(ref input._reference, shape, input.Strides, input._memoryLength);
+
+            if (!TensorHelpers.AreShapesBroadcastCompatible(input.Lengths, shape))
+                ThrowHelper.ThrowArgument_ShapesNotBroadcastCompatible();
+
+            nint newSize = TensorSpanHelpers.CalculateTotalLength(shape);
+
+            if (newSize == input.FlattenedLength)
+                return Reshape(input, shape);
+
+            nint[] intermediateShape = TensorHelpers.GetIntermediateShape(input.Lengths, shape.Length);
+            nint[] strides = new nint[shape.Length];
+
+            nint stride = 1;
+
+            for (int i = strides.Length - 1; i >= 0; i--)
+            {
+                if ((intermediateShape[i] == 1 && shape[i] != 1) || (intermediateShape[i] == 1 && shape[i] == 1))
+                    strides[i] = 0;
+                else
+                {
+                    strides[i] = stride;
+                    stride *= intermediateShape[i];
+                }
+            }
+
+            TensorSpan<T> output = new TensorSpan<T>(ref input._reference, shape, strides, input._memoryLength);
+
+            return output;
+        }
+        #endregion
+
+        #region Reverse
+        /// <summary>
+        /// Reverse the order of elements in the <paramref name="input"/> along the given axis. The shape of the tensor is preserved, but the elements are reordered.
+        /// <paramref name="axis"/> defaults to -1 when not provided, which reverses the entire span.
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="axis">Axis along which to reverse over. The default, -1, will reverse over all of the axes of the left span.</param>
+        public static TensorSpan<T> Reverse<T>(TensorSpan<T> input, nint axis = -1)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            if (axis == -1)
+            {
+                nint index = input.FlattenedLength - 1;
+                Span<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+                T temp;
+                for (int i = 0; i <= input.FlattenedLength / 2; i++)
+                {
+                    temp = span[(int)index];
+                    span[(int)index] = span[i];
+                    span[i] = temp;
+                }
+            }
+            else
+            {
+                T[] values = new T[input.FlattenedLength];
+
+                nint copyLength = 1;
+                for (nint i = axis; i < input.Lengths.Length; i++)
+                {
+                    copyLength *= input.Lengths[(int)i];
+                }
+                copyLength /= input.Lengths[(int)axis];
+
+                scoped Span<nint> oIndices;
+                nint[]? oIndicesArray;
+                scoped Span<nint> iIndices;
+                nint[]? iIndicesArray;
+                if (input.Rank > 6)
+                {
+                    oIndicesArray = ArrayPool<nint>.Shared.Rent(input.Rank);
+                    oIndices = oIndicesArray;
+                    iIndicesArray = ArrayPool<nint>.Shared.Rent(input.Rank);
+                    iIndices = iIndicesArray;
+                }
+                else
+                {
+                    oIndicesArray = null;
+                    oIndices = stackalloc nint[input.Rank];
+                    iIndicesArray = null;
+                    iIndices = stackalloc nint[input.Rank];
+                }
+
+                iIndices[(int)axis] = input.Lengths[(int)axis] - 1;
+                nint copiedValues = 0;
+                TensorSpan<T> islice = input.Slice(input.Lengths);
+                while (copiedValues < input.FlattenedLength)
+                {
+                    TensorSpanHelpers.Memmove(ref Unsafe.Add(ref values, TensorSpanHelpers.ComputeLinearIndex(oIndices, input.Strides, input.Lengths)), ref Unsafe.Add(ref islice._reference, TensorSpanHelpers.ComputeLinearIndex(iIndices, islice.Strides, islice.Lengths)), copyLength);
+                    TensorSpanHelpers.AdjustIndexes((int)axis, 1, oIndices, input.Lengths);
+                    TensorSpanHelpers.AdjustIndexesDown((int)axis, 1, iIndices, input.Lengths);
+                    copiedValues += copyLength;
+                }
+                TensorSpanHelpers.Memmove(ref input._reference, ref values[0], input.FlattenedLength);
+
+                if (oIndicesArray != null && iIndicesArray != null)
+                {
+                    ArrayPool<nint>.Shared.Return(oIndicesArray);
+                    ArrayPool<nint>.Shared.Return(iIndicesArray);
+                }
+            }
+
+            return input;
+        }
+        #endregion
+
+        #region Reshape
+        /// <summary>
+        /// Reshapes the <paramref name="input"/> tensor to the specified <paramref name="lengths"/>. If one of the lengths is -1, it will be calculated automatically.
+        /// Does not change the length of the underlying memory nor does it allocate new memory. If the new shape is not compatible with the old shape,
+        /// an exception is thrown.
+        /// </summary>
+        /// <param name="input"><see cref="TensorSpan{T}"/> you want to reshape.</param>
+        /// <param name="lengths"><see cref="ReadOnlySpan{T}"/> with the new dimensions.</param>
+        public static TensorSpan<T> Reshape<T>(this TensorSpan<T> input, params ReadOnlySpan<nint> lengths)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            nint[] arrLengths = lengths.ToArray();
+            // Calculate wildcard info.
+            if (lengths.Contains(-1))
+            {
+                if (lengths.Count(-1) > 1)
+                    ThrowHelper.ThrowArgument_OnlyOneWildcard();
+                nint tempTotal = input.FlattenedLength;
+                for (int i = 0; i < lengths.Length; i++)
+                {
+                    if (lengths[i] != -1)
+                    {
+                        tempTotal /= lengths[i];
+                    }
+                }
+                arrLengths[lengths.IndexOf(-1)] = tempTotal;
+
+            }
+
+            nint tempLinear = TensorSpanHelpers.CalculateTotalLength(arrLengths);
+            if (tempLinear != input.FlattenedLength)
+                ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
+            nint[] strides = TensorSpanHelpers.CalculateStrides(arrLengths);
+            return new TensorSpan<T>(ref input._reference, arrLengths, strides, input._memoryLength);
+        }
+        #endregion
+
+        #region Resize
+        /// <summary>
+        /// Creates a new <see cref="TensorSpan{T}"/>, allocates new managed memory, and copies the data from <paramref name="input"/>. If the final shape is smaller all data after
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="shape"><see cref="ReadOnlySpan{T}"/> of the desired new shape.</param>
+        public static TensorSpan<T> Resize<T>(TensorSpan<T> input, ReadOnlySpan<nint> shape)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            nint newSize = TensorSpanHelpers.CalculateTotalLength(shape);
+            T[] values = new T[newSize];
+            TensorSpan<T> output = new TensorSpan<T>(values, 0, shape, default);
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            if (newSize > input.FlattenedLength)
+                TensorSpanHelpers.Memmove(ospan, span, input.FlattenedLength);
+            else
+                TensorSpanHelpers.Memmove(ospan, span, newSize);
+
+            return output;
+        }
+        #endregion
+
+        #region Squeeze
+        // REVIEW: NAME?
+        /// <summary>
+        /// Removes axis of length one from the <paramref name="input"/>. <paramref name="axis"/> defaults to -1 and will remove all axis with length of 1.
+        /// If <paramref name="axis"/> is specified, it will only remove that axis and if it is not of length one it will throw an exception.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to remove axis of length 1.</param>
+        /// <param name="axis">The axis to remove. Defaults to -1 which removes all axis of length 1.</param>
+        public static TensorSpan<T> Squeeze<T>(TensorSpan<T> input, int axis = -1)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            if (axis >= input.Rank)
+                ThrowHelper.ThrowArgument_AxisLargerThanRank();
+
+            nint[] lengths;
+            nint[] strides;
+
+            List<nint> tempLengths = new List<nint>();
+            if (axis == -1)
+            {
+                for (int i = 0; i < input.Lengths.Length; i++)
+                {
+                    if (input.Lengths[i] != 1)
+                    {
+                        tempLengths.Add(input.Lengths[i]);
+                    }
+                }
+                lengths = tempLengths.ToArray();
+                strides = TensorSpanHelpers.CalculateStrides(lengths);
+            }
+            else
+            {
+                if (input.Lengths[axis] != 1)
+                {
+                    ThrowHelper.ThrowArgument_InvalidSqueezeAxis();
+                }
+                for (int i = 0; i < input.Lengths.Length; i++)
+                {
+                    if (i != axis)
+                    {
+                        tempLengths.Add(input.Lengths[i]);
+                    }
+                }
+                lengths = tempLengths.ToArray();
+                strides = TensorSpanHelpers.CalculateStrides(lengths);
+            }
+
+            return new TensorSpan<T>(ref input._reference, lengths, strides, input._memoryLength);
+        }
+        #endregion
+
+        #region Unsqueeze
+        // REVIEW: NAME? NUMPY CALLS THIS expand_dims.
+        /// <summary>
+        /// Insert a new axis of length 1 that will appear at the axis position.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to remove axis of length 1.</param>
+        /// <param name="axis">The axis to add.</param>
+        public static TensorSpan<T> Unsqueeze<T>(TensorSpan<T> input, int axis)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            if (axis > input.Lengths.Length)
+                ThrowHelper.ThrowArgument_AxisLargerThanRank();
+            if (axis < 0)
+                axis = input.Rank - axis;
+
+            List<nint> tempLengths = input._lengths.ToArray().ToList();
+            tempLengths.Insert(axis, 1);
+            nint[] lengths = tempLengths.ToArray();
+            nint[] strides = TensorSpanHelpers.CalculateStrides(lengths);
+            return new TensorSpan<T>(ref input._reference, lengths, strides, input._memoryLength);
+        }
+        #endregion
+
+        #region StdDev
+        /// <summary>
+        /// Returns the standard deviation of the elements in the <paramref name="input"/> tensor.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the standard deviation of.</param>
+        /// <returns><typeparamref name="T"/> representing the standard deviation.</returns>
+        public static T StdDev<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>, IPowerFunctions<T>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+
+        {
+            T mean = Mean(input);
+            Span<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._flattenedLength);
+            Span<T> output = new T[input._flattenedLength].AsSpan();
+            TensorPrimitives.Subtract(span, mean, output);
+            TensorPrimitives.Abs(output, output);
+            TensorPrimitives.Pow((ReadOnlySpan<T>)output, T.CreateChecked(2), output);
+            T sum = TensorPrimitives.Sum((ReadOnlySpan<T>)output);
+            return T.CreateChecked(sum / T.CreateChecked(input.FlattenedLength));
+        }
+
+        /// <summary>
+        /// Return the standard deviation of the elements in the <paramref name="input"/> tensor. Casts the return value to <typeparamref name="TResult"/>.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the standard deviation of.</param>
+        /// <returns><typeparamref name="TResult"/> representing the standard deviation.</returns>
+        public static TResult StdDev<T, TResult>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>, IFloatingPoint<T>, IPowerFunctions<T>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+            where TResult : IEquatable<TResult>, IEqualityOperators<TResult, TResult, bool>, IFloatingPoint<TResult>
+
+        {
+            T mean = Mean(input);
+            Span<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._flattenedLength);
+            Span<T> output = new T[input._flattenedLength].AsSpan();
+            TensorPrimitives.Subtract(span, mean, output);
+            TensorPrimitives.Abs(output, output);
+            TensorPrimitives.Pow((ReadOnlySpan<T>)output, T.CreateChecked(2), output);
+            T sum = TensorPrimitives.Sum((ReadOnlySpan<T>)output);
+            return TResult.CreateChecked(sum / T.CreateChecked(input.FlattenedLength));
+        }
+
+        #endregion
+
+        #region Mean
+        /// <summary>
+        /// Returns the mean of the elements in the <paramref name="input"/> tensor.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the mean of.</param>
+        /// <returns><typeparamref name="T"/> representing the mean.</returns>
+        public static T Mean<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+
+        {
+            T sum = Sum(input);
+            return T.CreateChecked(sum / T.CreateChecked(input.FlattenedLength));
+        }
+
+        /// <summary>
+        /// Return the mean of the elements in the <paramref name="input"/> tensor. Casts the return value to <typeparamref name="TResult"/>.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the mean of.</param>
+        /// <returns><typeparamref name="TResult"/> representing the mean.</returns>
+        public static TResult Mean<T, TResult>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+            where TResult : IEquatable<TResult>, IEqualityOperators<TResult, TResult, bool>, IFloatingPoint<TResult>
+
+        {
+            T sum = Sum(input);
+            return TResult.CreateChecked(TResult.CreateChecked(sum) / TResult.CreateChecked(input.FlattenedLength));
+        }
+
+        #endregion
+
+        #region TensorPrimitives
+        #region Abs
+        /// <summary>
+        /// Takes the absolute value of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> Abs<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumberBase<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Abs);
+        }
+
+        /// <summary>
+        /// Takes the absolute of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> AbsInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumberBase<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Abs, true);
+        }
+        #endregion
+
+        #region Acos
+        /// <summary>
+        /// Takes the inverse cosine of each element of the <see cref="Tensor{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> Acos<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Acos);
+        }
+
+        /// <summary>
+        /// Takes the inverse cosine of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> AcosInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Acos, true);
+        }
+        #endregion
+
+        #region Acosh
+        /// <summary>
+        /// Takes the inverse hyperbolic cosine of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> Acosh<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Acosh);
+        }
+
+        /// <summary>
+        /// Takes the inverse hyperbolic cosine of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="Tensor{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> AcoshInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Acosh, true);
+        }
+        #endregion
+
+        #region AcosPi
+        /// <summary>
+        /// Takes the inverse hyperbolic cosine divided by pi of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> AcosPi<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AcosPi);
+        }
+
+        /// <summary>
+        /// Takes the inverse hyperbolic cosine divided by pi of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> AcosPiInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AcosPi, true);
+        }
+        #endregion
+
+        #region Add
+        /// <summary>
+        /// Adds each element of <paramref name="left"/> to each element of <paramref name="right"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="left">The <see cref="TensorSpan{T}"/> of values to add.</param>
+        /// <param name="right">The second <see cref="TensorSpan{T}"/> of values to add.</param>
+        public static TensorSpan<T> Add<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Add);
+        }
+
+        /// <summary>
+        /// Adds each element of <paramref name="left"/> to each element of <paramref name="right"/> in place.
+        /// </summary>
+        /// <param name="left">The <see cref="TensorSpan{T}"/> of values to add.</param>
+        /// <param name="right">The second <see cref="TensorSpan{T}"/> of values to add.</param>
+        public static TensorSpan<T> AddInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Add, true);
+        }
+
+        /// <summary>
+        /// Adds <paramref name="val"/> to each element of <paramref name="input"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> of values to add.</param>
+        /// <param name="val">The <typeparamref name="T"/> to add to each element of <paramref name="input"/>.</param>
+        public static TensorSpan<T> Add<T>(TensorSpan<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            return TensorPrimitivesHelperSpanInTInSpanOut(input, val, TensorPrimitives.Add);
+        }
+
+        /// <summary>
+        /// Adds <paramref name="val"/> to each element of <paramref name="input"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> of values to add.</param>
+        /// <param name="val">The <typeparamref name="T"/> to add to each element of <paramref name="input"/>.</param>
+        public static TensorSpan<T> AddInPlace<T>(TensorSpan<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            return TensorPrimitivesHelperSpanInTInSpanOut(input, val, TensorPrimitives.Add, true);
+
+        }
+        #endregion
+
+        #region Asin
+        /// <summary>
+        /// Takes the inverse sin of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> Asin<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Asin);
+        }
+
+        /// <summary>
+        /// Takes the inverse sine each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> AsinInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Asin, true);
+        }
+        #endregion
+
+        #region Asinh
+        /// <summary>
+        /// Takes the inverse hyperbolic sine of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> Asinh<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Asinh);
+        }
+
+        /// <summary>
+        /// Takes the inverse hyperbolic sine each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> AsinhInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Asinh, true);
+        }
+        #endregion
+
+        #region AsinPi
+        /// <summary>
+        /// Takes the inverse hyperbolic sine divided by pi of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> AsinPi<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AsinPi);
+        }
+
+        /// <summary>
+        /// Takes the inverse hyperbolic sine divided by pi of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> AsinPiInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AsinPi, true);
+        }
+        #endregion
+
+        #region Atan
+        /// <summary>
+        /// Takes the arc tangent of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/></param>
+        public static TensorSpan<T> Atan<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Atan);
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/></param>
+        public static TensorSpan<T> AtanInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Atan, true);
+        }
+        #endregion
+
+        #region Atan2
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="left">The left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Atan2<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Atan2);
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="left">The left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Atan2InPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Atan2, true);
+        }
+        #endregion
+
+        #region Atan2Pi
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="TensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="left">The left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Atan2Pi<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Atan2Pi);
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="TensorSpan{T}"/>, divides each element by pi in place.
+        /// </summary>
+        /// <param name="left">The left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Atan2PiInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Atan2Pi, true);
+        }
+        #endregion
+
+        #region Atanh
+        /// <summary>
+        /// Takes the inverse hyperbolic tangent of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Atanh<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Atanh);
+        }
+
+        /// <summary>
+        /// Takes the inverse hyperbolic tangent of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> AtanhInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Atanh, true);
+        }
+        #endregion
+
+        #region AtanPi
+        /// <summary>
+        /// Takes the inverse hyperbolic tangent divided by pi of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The input<see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> AtanPi<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AtanPi);
+        }
+
+        /// <summary>
+        /// Takes the inverse hyperbolic tangent divided by pi of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The input<see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> AtanPiInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.AtanPi, true);
+        }
+        #endregion
+
+        #region BitwiseAnd
+        /// <summary>
+        /// Computes the element-wise bitwise and of the two input <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="left">The left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> BitwiseAnd<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.BitwiseAnd);
+        }
+
+        /// <summary>
+        /// Computes the element-wise bitwise and of the two input <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="left">The left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> BitwiseAndInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.BitwiseAnd, true);
+        }
+        #endregion
+
+        #region BitwiseOr
+        /// <summary>
+        /// Computes the element-wise bitwise of of the two input <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="left">The left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> BitwiseOr<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.BitwiseOr);
+        }
+
+        /// <summary>
+        /// Computes the element-wise bitwise of of the two input <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="left">The left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> BitwiseOrInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.BitwiseOr, true);
+        }
+        #endregion
+
+        #region CubeRoot
+        /// <summary>
+        /// Computes the element-wise cube root of the input <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The left <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> CubeRoot<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cbrt);
+        }
+
+        /// <summary>
+        /// Computes the element-wise cube root of the input <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The left <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> CubeRootInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cbrt, true);
+        }
+        #endregion
+
+        #region Ceiling
+        /// <summary>
+        /// Computes the element-wise ceiling of the input <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The left <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Ceiling<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Ceiling);
+        }
+
+        /// <summary>
+        /// Computes the element-wise ceiling of the input <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The left <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> CeilingInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Ceiling, true);
+        }
+        #endregion
+
+        #region ConvertChecked
+        /// <summary>
+        /// Copies <paramref name="source"/> to a new <see cref="TensorSpan{TTo}"/> converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
+        /// </summary>
+        /// <param name="source">The input <see cref="TensorSpan{TTo}"/>.</param>
+        public static TensorSpan<TTo> ConvertChecked<TFrom, TTo>(TensorSpan<TFrom> source)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            return TensorPrimitivesHelperTFromSpanInTToSpanOut<TFrom, TTo>(source, TensorPrimitives.ConvertChecked);
+        }
+        #endregion
+
+        #region ConvertSaturating
+        /// <summary>
+        /// Copies <paramref name="source"/> to a new <see cref="TensorSpan{TTo}"/> converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
+        /// </summary>
+        /// <param name="source">The input <see cref="TensorSpan{TTo}"/>.</param>
+        public static TensorSpan<TTo> ConvertSaturating<TFrom, TTo>(TensorSpan<TFrom> source)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            return TensorPrimitivesHelperTFromSpanInTToSpanOut<TFrom, TTo>(source, TensorPrimitives.ConvertSaturating);
+        }
+        #endregion
+
+        #region ConvertTruncating
+        /// <summary>
+        /// Copies <paramref name="source"/> to a new <see cref="TensorSpan{TTo}"/> converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
+        /// </summary>
+        /// <param name="source">The input <see cref="TensorSpan{TTo}"/>.</param>
+        public static TensorSpan<TTo> ConvertTruncating<TFrom, TTo>(TensorSpan<TFrom> source)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            return TensorPrimitivesHelperTFromSpanInTToSpanOut<TFrom, TTo>(source, TensorPrimitives.ConvertTruncating);
+        }
+        #endregion
+
+        #region CopySign
+        /// <summary>
+        /// Computes the element-wise result of copying the sign from one number to another number in the specified tensors and returns a new tensor with the result.
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="sign">The number with the associated sign.</param>
+        public static TensorSpan<T> CopySign<T>(TensorSpan<T> input, T sign)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTInSpanOut(input, sign, TensorPrimitives.CopySign);
+        }
+
+        /// <summary>
+        /// Computes the element-wise result of copying the sign from one number to another number in the specified tensors in place.
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="sign">The number with the associated sign.</param>
+        public static TensorSpan<T> CopySignInPlace<T>(TensorSpan<T> input, T sign)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTInSpanOut(input, sign, TensorPrimitives.CopySign, true);
+        }
+
+        /// <summary>
+        /// Computes the element-wise result of copying the sign from one number to another number in the specified tensors and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="sign">The <see cref="TensorSpan{T}"/> with the associated signs.</param>
+        public static TensorSpan<T> CopySign<T>(TensorSpan<T> input, TensorSpan<T> sign)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(input, sign, TensorPrimitives.CopySign);
+        }
+
+        /// <summary>
+        /// Computes the element-wise result of copying the sign from one number to another number in the specified tensors in place.
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="sign">The <see cref="TensorSpan{T}"/> with the associated signs.</param>
+        public static TensorSpan<T> CopySignInPlace<T>(TensorSpan<T> input, TensorSpan<T> sign)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(input, sign, TensorPrimitives.CopySign, true);
+        }
+        #endregion
+
+        #region Cos
+        /// <summary>
+        /// Takes the cosine of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the cosine of.</param>
+        public static TensorSpan<T> Cos<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cos);
+        }
+
+        /// <summary>
+        /// Takes the cosine of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the cosine of.</param>
+        public static TensorSpan<T> CosInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cos, true);
+        }
+        #endregion
+
+        #region Cosh
+        /// <summary>
+        /// Takes the hyperbolic cosine of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the cosine of.</param>
+        public static TensorSpan<T> Cosh<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cosh);
+        }
+
+        /// <summary>
+        /// Takes the hyperbolic cosine of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the cosine of.</param>
+        public static TensorSpan<T> CoshInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Cosh, true);
+        }
+        #endregion
+
+        #region CosineSimilarity
+        /// <summary>
+        /// Compute cosine similarity between <paramref name="left"/> and <paramref name="right"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="TensorSpan{T}"/></param>
+        /// <param name="right">The second <see cref="TensorSpan{T}"/></param>
+        public static TensorSpan<T> CosineSimilarity<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            if (left.Rank != 2)
+                ThrowHelper.ThrowArgument_2DTensorRequired(nameof(left));
+
+            if (right.Rank != 2)
+                ThrowHelper.ThrowArgument_2DTensorRequired(nameof(right));
+
+            if (left.Lengths[1] != right.Lengths[1])
+                ThrowHelper.ThrowArgument_IncompatibleDimensions(left.Lengths[1], right.Lengths[1]);
+
+            nint dim1 = left.Lengths[0];
+            nint dim2 = right.Lengths[0];
+
+            T[] values = new T[dim1 * dim2];
+
+            scoped Span<nint> leftIndexes = stackalloc nint[2];
+            scoped Span<nint> rightIndexes = stackalloc nint[2];
+
+            int outputOffset = 0;
+
+            ReadOnlySpan<T> lspan;
+            ReadOnlySpan<T> rspan;
+            int rowLength = (int)left.Lengths[1];
+            for (int i = 0; i < dim1; i++)
+            {
+                for (int j = 0; j < dim2; j++)
+                {
+                    lspan = MemoryMarshal.CreateSpan(ref left[leftIndexes], rowLength);
+                    rspan = MemoryMarshal.CreateSpan(ref right[rightIndexes], rowLength);
+                    values[outputOffset++] = TensorPrimitives.CosineSimilarity(lspan, rspan);
+                    rightIndexes[0]++;
+                }
+                rightIndexes[0] = 0;
+                leftIndexes[0]++;
+            }
+
+            return new TensorSpan<T>(values, 0, [dim1, dim2], []);
+
+        }
+        #endregion
+
+        #region CosPi
+        /// <summary>Computes the element-wise cosine of the value in the specified tensor that has been multiplied by Pi and returns a new <see cref="TensorSpan{T}"/> with the results.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/></param>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><typeparamref name="T"/>.CosPi(<paramref name="input" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi/180 to convert degrees to radians.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static TensorSpan<T> CosPi<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.CosPi);
+        }
+
+        /// <summary>Computes the element-wise cosine of the value in the specified tensor that has been multiplied by Pi in place.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/></param>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><typeparamref name="T"/>.CosPi(<paramref name="input" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians"/> or multiply by <typeparamref name="T"/>.Pi/180 to convert degrees to radians.
+        /// </para>
+        /// <para>
+        /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different
+        /// operating systems or architectures.
+        /// </para>
+        /// </remarks>
+        public static TensorSpan<T> CosPiInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.CosPi, true);
+        }
+        #endregion
+
+        #region DegreesToRadians
+        /// <summary>
+        /// Computes the element-wise conversion of each number of degrees in the specified tensor to radians and returns a new tensor with the results.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> DegreesToRadians<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.DegreesToRadians);
+        }
+
+        /// <summary>
+        /// Computes the element-wise conversion of each number of degrees in the specified tensor to radians in place.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> DegreesToRadiansInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.DegreesToRadians, true);
+        }
+        #endregion
+
+        #region Distance
+        /// <summary>
+        /// Computes the distance between two points, specified as non-empty, equal-length tensors of numbers, in Euclidean space.
+        /// </summary>
+        /// <param name="left">The input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The input <see cref="TensorSpan{T}"/>.</param>
+        public static T Distance<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInTOut(left, right, TensorPrimitives.Distance);
+        }
+
+        #endregion
+
+        #region Divide
+        /// <summary>
+        /// Divides each element of <paramref name="input"/> by <paramref name="val"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="val">The divisor</param>
+        public static TensorSpan<T> Divide<T>(TensorSpan<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            T[] values = new T[input.FlattenedLength];
+            TensorSpan<T> output = new TensorSpan<T>(values, 0, input.Lengths, default);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            TensorPrimitives.Divide(span, val, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Divides each element of <paramref name="input"/> by <paramref name="val"/> in place.
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="val">The divisor</param>
+        public static TensorSpan<T> DivideInPlace<T>(TensorSpan<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            TensorSpan<T> output = input;
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            TensorPrimitives.Divide(span, val, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Divides <paramref name="val"/> by each element of <paramref name="input"/> and returns a new <see cref="TensorSpan{T}"/> with the result."/>
+        /// </summary>
+        /// <param name="val">The value to be divided.</param>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> divisor.</param>
+        public static TensorSpan<T> Divide<T>(T val, TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            T[] values = new T[input.FlattenedLength];
+            TensorSpan<T> output = new TensorSpan<T>(values, 0, input.Lengths, default);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            TensorPrimitives.Divide(val, span, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Divides <paramref name="val"/> by each element of <paramref name="input"/> in place.
+        /// </summary>
+        /// <param name="val">The value to be divided.</param>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> divisor.</param>
+        public static TensorSpan<T> DivideInPlace<T>(T val, TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            TensorSpan<T> output = input;
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            TensorPrimitives.Divide(val, span, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Divides each element of <paramref name="left"/> by its corresponding element in <paramref name="right"/> and returns
+        /// a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="left">The <see cref="TensorSpan{T}"/> to be divided.</param>
+        /// <param name="right">The <see cref="TensorSpan{T}"/> divisor.</param>
+        public static TensorSpan<T> Divide<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Divide);
+        }
+
+        /// <summary>
+        /// Divides each element of <paramref name="left"/> by its corresponding element in <paramref name="right"/> in place.
+        /// </summary>
+        /// <param name="left">The <see cref="TensorSpan{T}"/> to be divided.</param>
+        /// <param name="right">The <see cref="TensorSpan{T}"/> divisor.</param>
+        public static TensorSpan<T> DivideInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Divide, true);
+        }
+        #endregion
+
+        #region Dot
+        /// <summary>
+        /// Computes the dot product of two tensors containing numbers.
+        /// </summary>
+        /// <param name="left">The input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The input <see cref="TensorSpan{T}"/>.</param>
+        public static T Dot<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplicativeIdentity<T, T>, IMultiplyOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInTOut(left, right, TensorPrimitives.Dot);
+        }
+
+        #endregion
+
+        #region Exp
+        /// <summary>
+        /// Computes the element-wise result of raising <c>e</c> to the single-precision floating-point number powers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Exp<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp);
+        }
+
+        /// <summary>
+        /// Computes the element-wise result of raising <c>e</c> to the single-precision floating-point number powers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> ExpInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp, true);
+        }
+        #endregion
+
+        #region Exp10
+        /// <summary>
+        /// Computes the element-wise result of raising 10 to the number powers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Exp10<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp10);
+        }
+
+        /// <summary>
+        /// Computes the element-wise result of raising 10 to the number powers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Exp10InPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp10, true);
+        }
+        #endregion
+
+        #region Exp10M1
+        /// <summary>Computes the element-wise result of raising 10 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Exp10M1<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp10M1);
+        }
+
+        /// <summary>Computes the element-wise result of raising 10 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Exp10M1InPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp10M1, true);
+        }
+        #endregion
+
+        #region Exp2
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Exp2<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp2);
+        }
+
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Exp2InPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp2, true);
+        }
+        #endregion
+
+        #region Exp2M1
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Exp2M1<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp2M1);
+        }
+
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Exp2M1InPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Exp2M1, true);
+        }
+        #endregion
+
+        #region ExpM1
+        /// <summary>Computes the element-wise result of raising <c>e</c> to the number powers in the specified tensor, minus 1.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> ExpM1<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.ExpM1);
+        }
+
+        /// <summary>Computes the element-wise result of raising <c>e</c> to the number powers in the specified tensor, minus 1.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> ExpM1InPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.ExpM1, true);
+        }
+        #endregion
+
+        #region Floor
+        /// <summary>Computes the element-wise floor of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Floor<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Floor);
+        }
+
+        /// <summary>Computes the element-wise floor of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> FloorInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Floor, true);
+        }
+        #endregion
+
+        #region Hypotenuse
+        /// <summary>
+        /// Computes the element-wise hypotenuse given values from two tensors representing the lengths of the shorter sides in a right-angled triangle.
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// </summary>
+        /// <param name="left">Left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">Right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Hypotenuse<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Hypot);
+        }
+
+        /// <summary>
+        /// Computes the element-wise hypotenuse given values from two tensors representing the lengths of the shorter sides in a right-angled triangle.
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// </summary>
+        /// <param name="left">Left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">Right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> HypotenuseInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Hypot, true);
+        }
+        #endregion
+
+        #region Ieee754Remainder
+        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// <param name="left">Left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">Right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Ieee754Remainder<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Ieee754Remainder);
+        }
+
+        /// <summary>
+        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// </summary>
+        /// <param name="left">Left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">Right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Ieee754RemainderInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Ieee754Remainder, true);
+        }
+        #endregion
+
+        #region ILogB
+        /// <summary>Computes the element-wise floor of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<int> ILogB<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPointIeee754<T>
+        {
+            return TensorPrimitivesHelperSpanInIntSpanOut(input, TensorPrimitives.ILogB);
+        }
+        #endregion
+
+        #region IndexOfMax
+        /// <summary>Searches for the index of the largest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static int IndexOfMax<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._flattenedLength);
+            return TensorPrimitives.IndexOfMax(span);
+        }
+        #endregion
+
+        #region IndexOfMaxMagnitude
+        /// <summary>Searches for the index of the number with the largest magnitude in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static int IndexOfMaxMagnitude<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._flattenedLength);
+            return TensorPrimitives.IndexOfMaxMagnitude(span);
+        }
+        #endregion
+
+        #region IndexOfMin
+        /// <summary>Searches for the index of the smallest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static int IndexOfMin<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._flattenedLength);
+            return TensorPrimitives.IndexOfMin(span);
+        }
+        #endregion
+
+        #region IndexOfMinMagnitude
+        /// <summary>
+        /// Searches for the index of the number with the smallest magnitude in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static int IndexOfMinMagnitude<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._flattenedLength);
+            return TensorPrimitives.IndexOfMinMagnitude(span);
+        }
+        #endregion
+
+        #region LeadingZeroCount
+        /// <summary>
+        /// Computes the element-wise leading zero count of numbers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> LeadingZeroCount<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.LeadingZeroCount);
+        }
+
+        /// <summary>
+        /// Computes the element-wise leading zero count of numbers in the specified tensor.
+        /// </summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> LeadingZeroCountInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.LeadingZeroCount, true);
+        }
+        #endregion
+
+        #region Log
+
+        /// <summary>
+        /// Takes the natural logarithm of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the natural logarithm of.</param>
+        public static TensorSpan<T> Log<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log);
+        }
+
+        /// <summary>
+        /// Takes the natural logarithm of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the natural logarithm of.</param>
+        public static TensorSpan<T> LogInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log, true);
+        }
+        #endregion
+
+        #region Log10
+
+        /// <summary>
+        /// Takes the base 10 logarithm of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 10 logarithm of.</param>
+        public static TensorSpan<T> Log10<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log10);
+        }
+
+        /// <summary>
+        /// Takes the base 10 logarithm of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 10 logarithm of.</param>
+        public static TensorSpan<T> Log10InPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log10, true);
+        }
+        #endregion
+
+        #region Log10P1
+        /// <summary>
+        /// Takes the base 10 logarithm plus 1 of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 10 logarithm of.</param>
+        public static TensorSpan<T> Log10P1<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log10P1);
+        }
+
+        /// <summary>
+        /// Takes the base 10 logarithm plus 1 of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 10 logarithm of.</param>
+        public static TensorSpan<T> Log10P1InPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log10P1, true);
+        }
+        #endregion
+
+        #region Log2
+        /// <summary>
+        /// Takes the base 2 logarithm of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 2 logarithm of.</param>
+        public static TensorSpan<T> Log2<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log2);
+        }
+
+        /// <summary>
+        /// Takes the base 2 logarithm of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 2 logarithm of.</param>
+        public static TensorSpan<T> Log2InPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log2, true);
+        }
+        #endregion
+
+        #region Log2P1
+        /// <summary>
+        /// Takes the base 2 logarithm plus 1 of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 2 logarithm of.</param>
+        public static TensorSpan<T> Log2P1<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log2P1);
+        }
+
+        /// <summary>
+        /// Takes the base 2 logarithm plus 1 of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the base 2 logarithm of.</param>
+        public static TensorSpan<T> Log2P1InPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Log2P1, true);
+        }
+        #endregion
+
+        #region LogP1
+        /// <summary>
+        /// Takes the natural logarithm plus 1 of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the natural logarithm of.</param>
+        public static TensorSpan<T> LogP1<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.LogP1);
+        }
+
+        /// <summary>
+        /// Takes the natural logarithm plus 1 of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the natural logarithm of.</param>
+        public static TensorSpan<T> LogP1InPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ILogarithmicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.LogP1, true);
+        }
+        #endregion
+
+        #region Max
+        /// <summary>Searches for the largest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>..</param>
+        public static T Max<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.Max);
+        }
+        #endregion
+
+        #region MaxMagnitude
+        /// <summary>Searches for the number with the largest magnitude in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>..</param>
+        public static T MaxMagnitude<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.MaxMagnitude);
+        }
+        #endregion
+
+        #region MaxNumber
+        /// <summary>Searches for the largest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>..</param>
+        public static T MaxNumber<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.MaxNumber);
+        }
+        #endregion
+
+        #region Min
+        /// <summary>Searches for the smallest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static T Min<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.Min);
+        }
+        #endregion
+
+        #region MinMagnitude
+        /// <summary>Searches for the number with the smallest magnitude in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static T MinMagnitude<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.MinMagnitude);
+        }
+        #endregion
+
+        #region MinNumber
+        /// <summary>Searches for the smallest number in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>..</param>
+        public static T MinNumber<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, INumber<T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.MinNumber);
+        }
+        #endregion
+
+        #region Multiply
+        /// <summary>
+        /// Multiplies each element of <paramref name="input"/> with <paramref name="val"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/></param>
+        /// <param name="val"><typeparamref name="T"/> value to multiply by.</param>
+        public static TensorSpan<T> Multiply<T>(TensorSpan<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            T[] values = new T[input.FlattenedLength];
+            TensorSpan<T> output = new TensorSpan<T>(values, 0, input.Lengths, default);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            TensorPrimitives.Multiply(span, val, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Multiplies each element of <paramref name="input"/> with <paramref name="val"/> in place.
+        /// </summary>
+        /// <param name="input">Input <see cref="TensorSpan{T}"/></param>
+        /// <param name="val"><typeparamref name="T"/> value to multiply by.</param>
+        public static TensorSpan<T> MultiplyInPlace<T>(TensorSpan<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            TensorSpan<T> output = input;
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            TensorPrimitives.Multiply(span, val, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Multiplies each element of <paramref name="left"/> with <paramref name="right"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// </summary>
+        /// <param name="left">Left <see cref="TensorSpan{T}"/> for multiplication.</param>
+        /// <param name="right">Right <see cref="TensorSpan{T}"/> for multiplication.</param>
+        public static TensorSpan<T> Multiply<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Multiply);
+        }
+
+        /// <summary>
+        /// Multiplies each element of <paramref name="left"/> with <paramref name="right"/> in place.
+        /// If the shapes are not the same they are broadcast to the smallest compatible shape.
+        /// </summary>
+        /// <param name="left">Left <see cref="TensorSpan{T}"/> for multiplication.</param>
+        /// <param name="right">Right <see cref="TensorSpan{T}"/> for multiplication.</param>
+        public static TensorSpan<T> MultiplyInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Multiply, true);
+        }
+        #endregion
+
+        #region Negate
+        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/></param>
+        public static TensorSpan<T> Negate<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IUnaryNegationOperators<T, T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Negate);
+        }
+
+        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/></param>
+        public static TensorSpan<T> NegateInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IUnaryNegationOperators<T, T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Negate, true);
+        }
+        #endregion
+
+        #region Norm
+
+        /// <summary>
+        ///  Takes the norm of the <see cref="TensorSpan{T}"/> and returns the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the norm of.</param>
+        public static T Norm<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            return TensorPrimitives.Norm(span);
+        }
+        #endregion
+
+        #region OnesComplement
+        /// <summary>Computes the element-wise one's complement of numbers in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/></param>
+        public static TensorSpan<T> OnesComplement<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.OnesComplement);
+        }
+
+        /// <summary>Computes the element-wise one's complement of numbers in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/></param>
+        public static TensorSpan<T> OnesComplementInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.OnesComplement, true);
+        }
+        #endregion
+
+        #region PopCount
+        /// <summary>Computes the element-wise population count of numbers in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/></param>
+        public static TensorSpan<T> PopCount<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.PopCount);
+        }
+
+        /// <summary>Computes the element-wise population count of numbers in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/></param>
+        public static TensorSpan<T> PopCountInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.PopCount, true);
+        }
+        #endregion
+
+        #region Pow
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
+        /// <param name="left">The input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The second input <see cref="TensorSpan{T}"/></param>
+        public static TensorSpan<T> Pow<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IPowerFunctions<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Pow);
+        }
+
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
+        /// <param name="left">The input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The second input <see cref="TensorSpan{T}"/></param>
+        public static TensorSpan<T> PowInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IPowerFunctions<T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Pow, true);
+        }
+        #endregion
+
+        #region Product
+        /// <summary>Computes the product of all elements in the specified non-empty tensor of numbers.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static T Product<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplicativeIdentity<T, T>, IMultiplyOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperSpanInTOut(input, TensorPrimitives.Product);
+        }
+        #endregion
+
+        #region RadiansToDegrees
+        /// <summary>Computes the element-wise conversion of each number of radians in the specified tensor to degrees.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> RadiansToDegrees<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.RadiansToDegrees);
+        }
+
+        /// <summary>Computes the element-wise conversion of each number of radians in the specified tensor to degrees.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> RadiansToDegreesInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.RadiansToDegrees, true);
+        }
+        #endregion
+
+        #region Reciprocal
+        /// <summary>Computes the element-wise reciprocal of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Reciprocal<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Reciprocal);
+        }
+
+        /// <summary>Computes the element-wise reciprocal of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> ReciprocalInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Reciprocal, true);
+        }
+        #endregion
+
+        #region Round
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Round<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Round);
+        }
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> RoundInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Round, true);
+        }
+        #endregion
+
+        #region Sigmoid
+        /// <summary>Computes the element-wise sigmoid function on the specified non-empty tensor of numbers.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Sigmoid<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sigmoid);
+        }
+
+        /// <summary>Computes the element-wise sigmoid function on the specified non-empty tensor of numbers.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> SigmoidInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sigmoid, true);
+        }
+        #endregion
+
+        #region Sin
+
+        /// <summary>
+        /// Takes the sin of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> Sin<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sin);
+        }
+
+        /// <summary>
+        /// Takes the sin of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> SinInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sin, true);
+        }
+        #endregion
+
+        #region Sinh
+        /// <summary>Computes the element-wise hyperbolic sine of each radian angle in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> Sinh<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sinh);
+        }
+
+        /// <summary>Computes the element-wise hyperbolic sine of each radian angle in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> SinhInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sinh, true);
+        }
+        #endregion
+
+        #region SinPi
+        /// <summary>Computes the element-wise sine of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> SinPi<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.SinPi);
+        }
+
+        /// <summary>Computes the element-wise sine of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> SinPiInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.SinPi, true);
+        }
+        #endregion
+
+        #region SoftMax
+        /// <summary>Computes the softmax function over the specified non-empty tensor of numbers.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> SoftMax<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.SoftMax);
+        }
+
+        /// <summary>Computes the softmax function over the specified non-empty tensor of numbers.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> SoftMaxInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IExponentialFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.SoftMax, true);
+        }
+        #endregion
+
+        #region Sqrt
+        /// <summary>
+        /// Takes the square root of each element of the <see cref="TensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the square root of.</param>
+        public static TensorSpan<T> Sqrt<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sqrt);
+        }
+
+        /// <summary>
+        /// Takes the square root of each element of the <see cref="TensorSpan{T}"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the square root of.</param>
+        public static TensorSpan<T> SqrtInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IRootFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Sqrt, true);
+        }
+        #endregion
+
+        #region Subtract
+        /// <summary>
+        /// Subtracts <paramref name="val"/> from each element of <paramref name="input"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> with values to be subtracted from.</param>
+        /// <param name="val">The <typeparamref name="T"/> value to subtract.</param>
+        public static TensorSpan<T> Subtract<T>(TensorSpan<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            T[] values = new T[input.FlattenedLength];
+            TensorSpan<T> output = new TensorSpan<T>(values, 0, input.Lengths, default);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            TensorPrimitives.Subtract(span, val, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Subtracts <paramref name="val"/> from each element of <paramref name="input"/> in place.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> with values to be subtracted from.</param>
+        /// <param name="val">The <typeparamref name="T"/> value to subtract.</param>
+        public static TensorSpan<T> SubtractInPlace<T>(TensorSpan<T> input, T val)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            TensorSpan<T> output = input;
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            TensorPrimitives.Subtract(span, val, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Subtracts each element of <paramref name="input"/> from <paramref name="val"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="val">The <typeparamref name="T"/> value to be subtracted from.</param>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> values to subtract.</param>
+        public static TensorSpan<T> Subtract<T>(T val, TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            T[] values = new T[input.FlattenedLength];
+            TensorSpan<T> output = new TensorSpan<T>(values, 0, input.Lengths, default);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            TensorPrimitives.Subtract(val, span, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Subtracts each element of <paramref name="input"/> from <paramref name="val"/> in place.
+        /// </summary>
+        /// <param name="val">The <typeparamref name="T"/> value to be subtracted from.</param>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> values to subtract.</param>
+        public static TensorSpan<T> SubtractInPlace<T>(T val, TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            TensorSpan<T> output = input;
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            TensorPrimitives.Subtract(val, span, ospan);
+            return output;
+        }
+
+        /// <summary>
+        /// Subtracts each element of <paramref name="left"/> from <paramref name="right"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="left">The <see cref="TensorSpan{T}"/> of values to be subtracted from.</param>
+        /// <param name="right">The <see cref="TensorSpan{T}"/>of values to subtract.</param>
+        public static TensorSpan<T> Subtract<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Subtract);
+        }
+
+        /// <summary>
+        /// Subtracts each element of <paramref name="left"/> from <paramref name="right"/> in place.
+        /// </summary>
+        /// <param name="left">The <see cref="TensorSpan{T}"/> of values to be subtracted from.</param>
+        /// <param name="right">The <see cref="TensorSpan{T}"/>of values to subtract.</param>
+        public static TensorSpan<T> SubtractInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Subtract, true);
+        }
+        #endregion
+
+        #region Sum
+        /// <summary>
+        /// Sums all the elements of the <see cref="TensorSpan{T}"/> and returns the result.
+        /// </summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to sum.</param>
+        public static T Sum<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            return TensorPrimitives.Sum(span);
+        }
+        #endregion
+
+        #region Tan
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> Tan<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Tan);
+        }
+
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> TanInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Tan, true);
+        }
+        #endregion
+
+        #region Tanh
+        /// <summary>Computes the element-wise hyperbolic tangent of each radian angle in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> Tanh<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Tanh);
+        }
+
+        /// <summary>Computes the element-wise hyperbolic tangent of each radian angle in the specified tensor.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> TanhInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IHyperbolicFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Tanh, true);
+        }
+        #endregion
+
+        #region TanPi
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> TanPi<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.TanPi);
+        }
+
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="input">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        public static TensorSpan<T> TanPiInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ITrigonometricFunctions<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.TanPi, true);
+        }
+        #endregion
+
+        #region TrailingZeroCount
+        /// <summary>Computes the element-wise trailing zero count of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> TrailingZeroCount<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.TrailingZeroCount);
+        }
+
+        /// <summary>Computes the element-wise trailing zero count of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> TrailingZeroCountInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBinaryInteger<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.TrailingZeroCount, true);
+        }
+        #endregion
+
+        #region Truncate
+        /// <summary>Computes the element-wise truncation of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Truncate<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Truncate);
+        }
+
+        /// <summary>Computes the element-wise truncation of numbers in the specified tensor.</summary>
+        /// <param name="input">The input <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> TruncateInPlace<T>(TensorSpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IFloatingPoint<T>
+        {
+            return TensorPrimitivesHelperSpanInSpanOut(input, TensorPrimitives.Truncate, true);
+        }
+        #endregion
+
+        #region Xor
+        /// <summary>Computes the element-wise XOR of numbers in the specified tensors.</summary>
+        /// <param name="left">The left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> Xor<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Xor);
+        }
+
+        /// <summary>Computes the element-wise XOR of numbers in the specified tensors.</summary>
+        /// <param name="left">The left <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="right">The right <see cref="TensorSpan{T}"/>.</param>
+        public static TensorSpan<T> XorInPlace<T>(TensorSpan<T> left, TensorSpan<T> right)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IBitwiseOperators<T, T, T>
+        {
+            return TensorPrimitivesHelperTwoSpanInSpanOut(left, right, TensorPrimitives.Xor, true);
+        }
+        #endregion
+
+        #region TensorPrimitivesHelpers
+        private delegate void PerformCalculationSpanInSpanOut<T>(ReadOnlySpan<T> input, Span<T> output)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
+
+        private delegate void PerformCalculationSpanInTInSpanOut<T>(ReadOnlySpan<T> input, T value, Span<T> output)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
+
+        private delegate void PerformCalculationTwoSpanInSpanOut<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo, Span<T> output)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
+
+        private delegate void PerformCalculationTFromSpanInTToSpanOut<TFrom, TTo>(ReadOnlySpan<TFrom> input, Span<TTo> output)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>;
+
+        private delegate T PerformCalculationTwoSpanInTOut<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
+
+        private delegate void PerformCalculationSpanInIntSpanOut<T>(ReadOnlySpan<T> input, Span<int> output)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
+
+        private delegate T PerformCalculationSpanInTOut<T>(ReadOnlySpan<T> input)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>;
+
+        private static T TensorPrimitivesHelperSpanInTOut<T>(TensorSpan<T> input, PerformCalculationSpanInTOut<T> performCalculation)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._flattenedLength);
+            return performCalculation(span);
+        }
+
+        private static TensorSpan<int> TensorPrimitivesHelperSpanInIntSpanOut<T>(TensorSpan<T> input, PerformCalculationSpanInIntSpanOut<T> performCalculation)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._flattenedLength);
+            int[] data = new int[input.FlattenedLength];
+            performCalculation(span, data);
+            return new TensorSpan<int>(data, 0, input.Lengths, input.Strides);
+        }
+
+        private static T TensorPrimitivesHelperTwoSpanInTOut<T>(TensorSpan<T> left, TensorSpan<T> right, PerformCalculationTwoSpanInTOut<T> performCalculation)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            // If not in place but sizes are the same.
+            if (left.Lengths.SequenceEqual(right.Lengths))
+            {
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref left._reference, (int)left.FlattenedLength);
+                ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref right._reference, (int)right.FlattenedLength);
+                return performCalculation(span, rspan);
+            }
+            // Not in place and broadcasting needs to happen.
+            else
+            {
+                // Have a couple different possible cases here.
+                // 1 - Both tensors have row contiguous memory (i.e. a 1x5 being broadcast to a 5x5)
+                // 2 - One tensor has row contiguous memory and the right has column contiguous memory (i.e. a 1x5 and a 5x1)
+                // Because we are returning a single T though we need to actual realize the broadcasts at this point to perform the calculations.
+
+                var broadcastedLeft = Broadcast(left, right);
+                var broadcastedRight = Broadcast(right, left);
+
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref broadcastedLeft._reference, (int)broadcastedLeft.FlattenedLength);
+                ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref broadcastedRight._reference, (int)broadcastedRight.FlattenedLength);
+                return performCalculation(span, rspan);
+            }
+        }
+
+        private static TensorSpan<T> TensorPrimitivesHelperSpanInSpanOut<T>(TensorSpan<T> input, PerformCalculationSpanInSpanOut<T> performCalculation, bool inPlace = false)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            TensorSpan<T> output = inPlace ? input : new TensorSpan<T>(new T[input.FlattenedLength], 0, input.Lengths, input.Strides);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            performCalculation(span, ospan);
+            return output;
+        }
+
+        private static TensorSpan<T> TensorPrimitivesHelperSpanInTInSpanOut<T>(TensorSpan<T> input, T value, PerformCalculationSpanInTInSpanOut<T> performCalculation, bool inPlace = false)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
+            TensorSpan<T> output = inPlace ? input : new TensorSpan<T>(new T[input.FlattenedLength], 0, input.Lengths, input.Strides);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+            performCalculation(span, value, ospan);
+            return output;
+        }
+
+        private static TensorSpan<TTo> TensorPrimitivesHelperTFromSpanInTToSpanOut<TFrom, TTo>(TensorSpan<TFrom> input, PerformCalculationTFromSpanInTToSpanOut<TFrom, TTo> performCalculation)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            ReadOnlySpan<TFrom> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._flattenedLength);
+            TTo[] data = new TTo[(int)input.FlattenedLength];
+            TensorSpan<TTo> output = new TensorSpan<TTo>(data, 0, input.Lengths, input.Strides);
+            Span<TTo> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output._flattenedLength);
+            performCalculation(span, ospan);
+            return output;
+        }
+
+        private static TensorSpan<T> TensorPrimitivesHelperTwoSpanInSpanOut<T>(TensorSpan<T> left, TensorSpan<T> right, PerformCalculationTwoSpanInSpanOut<T> performCalculation, bool inPlace = false)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool>
+        {
+            if (inPlace && !left.Lengths.SequenceEqual(right.Lengths))
+                ThrowHelper.ThrowArgument_InPlaceInvalidShape();
+
+            TensorSpan<T> output;
+            if (inPlace)
+            {
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref left._reference, (int)left.FlattenedLength);
+                ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref right._reference, (int)right.FlattenedLength);
+                output = left;
+                Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+                performCalculation(span, rspan, ospan);
+            }
+            // If not in place but sizes are the same.
+            else if (left.Lengths.SequenceEqual(right.Lengths))
+            {
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref left._reference, (int)left.FlattenedLength);
+                ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref right._reference, (int)right.FlattenedLength);
+                output = new TensorSpan<T>(new T[left.FlattenedLength], 0, left.Lengths, left.Strides);
+                Span<T> ospan = MemoryMarshal.CreateSpan(ref output._reference, (int)output.FlattenedLength);
+                performCalculation(span, rspan, ospan);
+                return output;
+            }
+            // Not in place and broadcasting needs to happen.
+            else
+            {
+                // Have a couple different possible cases here.
+                // 1 - Both tensors have row contiguous memory (i.e. a 1x5 being broadcast to a 5x5)
+                // 2 - One tensor has row contiguous memory and the right has column contiguous memory (i.e. a 1x5 and a 5x1)
+
+                nint[] newSize = TensorHelpers.GetSmallestBroadcastableSize(left.Lengths, right.Lengths);
+
+                TensorSpan<T> broadcastedLeft = TensorSpan.BroadcastTo(left, newSize);
+                TensorSpan<T> broadcastedRight = TensorSpan.BroadcastTo(right, newSize);
+
+                output = new TensorSpan<T>(new T[TensorSpanHelpers.CalculateTotalLength(newSize)], newSize, default);
+                nint rowLength = newSize[^1];
+                Span<T> ospan;
+                Span<T> ispan;
+                Span<T> buffer = new T[rowLength];
+
+                scoped Span<nint> curIndex;
+                nint[]? curIndexArray;
+                if (newSize.Length > 6)
+                {
+                    curIndexArray = ArrayPool<nint>.Shared.Rent(newSize.Length);
+                    curIndex = curIndexArray;
+                }
+                else
+                {
+                    curIndexArray = null;
+                    curIndex = stackalloc nint[newSize.Length];
+                }
+
+                int outputOffset = 0;
+                // ADD IN CASE WHERE NEITHER ARE ROW CONTIGUOUS
+                // tensor not row contiguous
+                if (broadcastedLeft.Strides[^1] == 0)
+                {
+                    while (outputOffset < output.FlattenedLength)
+                    {
+                        ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref output._reference, outputOffset), (int)rowLength);
+                        buffer.Fill(broadcastedLeft[curIndex]);
+                        ispan = MemoryMarshal.CreateSpan(ref broadcastedRight[curIndex], (int)rowLength);
+                        performCalculation(buffer, ispan, ospan);
+                        outputOffset += (int)rowLength;
+                        TensorSpanHelpers.AdjustIndexes(broadcastedLeft.Rank - 2, 1, curIndex, broadcastedLeft.Lengths);
+                    }
+                }
+                // right not row contiguous
+                else if (broadcastedRight.Strides[^1] == 0)
+                {
+                    while (outputOffset < output.FlattenedLength)
+                    {
+                        ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref output._reference, outputOffset), (int)rowLength);
+                        buffer.Fill(broadcastedRight[curIndex]);
+                        ispan = MemoryMarshal.CreateSpan(ref broadcastedLeft[curIndex], (int)rowLength);
+                        performCalculation(ispan, buffer, ospan);
+                        outputOffset += (int)rowLength;
+                        TensorSpanHelpers.AdjustIndexes(broadcastedLeft.Rank - 2, 1, curIndex, broadcastedLeft.Lengths);
+                    }
+                }
+                // both row contiguous
+                else
+                {
+                    Span<T> rspan;
+                    while (outputOffset < output.FlattenedLength)
+                    {
+                        ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref output._reference, outputOffset), (int)rowLength);
+                        ispan = MemoryMarshal.CreateSpan(ref broadcastedLeft[curIndex], (int)rowLength);
+                        rspan = MemoryMarshal.CreateSpan(ref broadcastedRight[curIndex], (int)rowLength);
+                        performCalculation(ispan, rspan, ospan);
+                        outputOffset += (int)rowLength;
+                        TensorSpanHelpers.AdjustIndexes(broadcastedLeft.Rank - 2, 1, curIndex, broadcastedLeft.Lengths);
+                    }
+                }
+
+                if (curIndexArray != null)
+                    ArrayPool<nint>.Shared.Return(curIndexArray);
+            }
+            return output;
+        }
+        #endregion
+        #endregion
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.T.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.T.cs
index 5a55bebba6b4c..4e5103a0acd6e 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.T.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.T.cs
@@ -1,13 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Xml.Serialization;
 
 
 #pragma warning disable 8500 // sizeof of managed types
@@ -57,20 +52,5 @@ public static unsafe void Fill<T>(ref T dest, nuint numElements, T value)
                 numElements -= toFill;
             }
         }
-
-        public static bool SequenceEqual<T>(ref T first, ref T second, nuint length) where T : IEquatable<T>?
-        {
-            bool equal = true;
-            while (length > 0)
-            {
-                nuint toCompare = Math.Min(length, int.MaxValue);
-                equal &= MemoryMarshal.CreateSpan(ref first, (int)toCompare).SequenceEqual(MemoryMarshal.CreateSpan(ref second, (int)toCompare));
-                first = ref Unsafe.Add(ref first, toCompare);
-                second = ref Unsafe.Add(ref second, toCompare);
-                length -= toCompare;
-            }
-
-            return equal;
-        }
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.cs
index d40726f4ab832..344226025c277 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.cs
@@ -2,13 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Buffers;
+using System.Collections.Specialized;
 using System.Diagnostics;
+using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-using Microsoft.VisualBasic;
 
 #pragma warning disable 8500 // sizeof of managed types
 
@@ -16,6 +14,10 @@ namespace System.Numerics.Tensors
 {
     internal static partial class TensorSpanHelpers
     {
+
+        internal static bool AreShapesTheSame<T>(ReadOnlyTensorSpan<T> tensor1, ReadOnlyTensorSpan<T> tensor2)
+            where T : IEquatable<T>, IEqualityOperators<T, T, bool> => tensor1._lengths.SequenceEqual(tensor2._lengths);
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static nint CalculateTotalLength(ReadOnlySpan<nint> lengths)
         {
@@ -43,6 +45,34 @@ public static nint[] CalculateStrides(ReadOnlySpan<nint> lengths)
         {
             nint[] strides = new nint[lengths.Length];
 
+            if (lengths.Length == 1 && lengths[0] == 0 || lengths.Length == 0)
+            {
+                strides[0] = 0;
+                return strides;
+            }
+
+            nint stride = 1;
+
+            for (int i = strides.Length - 1; i >= 0; i--)
+            {
+                strides[i] = stride;
+                stride *= lengths[i];
+            }
+
+            return strides;
+        }
+
+        /// <summary>
+        /// Gets the set of strides that can be used to calculate the offset of n-dimensions in a 1-dimensional layout
+        /// </summary>
+        /// <returns></returns>
+        public static nint[] CalculateStrides(ReadOnlySpan<nint> lengths, nint linearLength)
+        {
+            nint[] strides = new nint[lengths.Length];
+
+            if (linearLength == 0)
+                return strides;
+
             nint stride = 1;
 
             for (int i = strides.Length - 1; i >= 0; i--)
@@ -76,23 +106,63 @@ public static nint ComputeLinearIndex(ReadOnlySpan<nint> indexes, ReadOnlySpan<n
             return index;
         }
 
+        public static nint ComputeMaxLinearIndex(ReadOnlySpan<nint> strides, ReadOnlySpan<nint> lengths)
+        {
+            Debug.Assert(strides.Length == lengths.Length);
+
+            nint index = 0;
+            for (int i = 0; i < lengths.Length; i++)
+            {
+                index += strides[i] * (lengths[i] - 1);
+            }
+
+            return index;
+        }
+
         /// <summary>
         /// Calculates the 1-d index for n-d indexes in layout specified by strides.
         /// </summary>
+        /// <param name="array"></param>
         /// <param name="indexes"></param>
-        /// <param name="strides"></param>
-        /// <param name="lengths"></param>
         /// <returns></returns>
-        public static nint ComputeLinearIndex(ReadOnlySpan<int> indexes, ReadOnlySpan<nint> strides, ReadOnlySpan<nint> lengths)
+        public static nint ComputeStartOffsetSystemArray(Array array, ReadOnlySpan<int> indexes)
         {
-            Debug.Assert(strides.Length == indexes.Length);
+            Debug.Assert(array.Rank == indexes.Length || indexes.Length == 0);
 
-            nint index = 0;
-            for (int i = 0; i < indexes.Length; i++)
+            if (indexes.Length == 0)
+                return 0;
+
+            nint index = indexes[indexes.Length - 1];
+            for (int i = indexes.Length - 2; i >= 0; i--)
             {
-                if (indexes[i] >= lengths[i] || indexes[i] < 0)
+                if ((indexes[i] != 0 && indexes[i] >= array.GetLength(i)) || indexes[i] < 0)
                     ThrowHelper.ThrowIndexOutOfRangeException();
-                index += strides[i] * indexes[i];
+                index += array.GetLength(i) * indexes[i];
+            }
+
+            return index;
+        }
+
+        /// <summary>
+        /// Calculates the 1-d index for n-d indexes in layout specified by strides.
+        /// </summary>
+        /// <param name="array"></param>
+        /// <param name="indexes"></param>
+        /// <returns></returns>
+        public static nint ComputeStartOffsetSystemArray(Array array, ReadOnlySpan<NIndex> indexes)
+        {
+            Debug.Assert(array.Rank == indexes.Length || indexes.Length == 0);
+
+            if (indexes.Length == 0)
+                return 0;
+
+            nint index = indexes[indexes.Length - 1].GetOffset(array.GetLength(indexes.Length - 1));
+            for (int i = indexes.Length - 2; i >= 0; i--)
+            {
+                nint offset = indexes[i].GetOffset(array.GetLength(i));
+                if ((offset != 0 && offset >= array.GetLength(i)) || offset < 0)
+                    ThrowHelper.ThrowIndexOutOfRangeException();
+                index += array.GetLength(i) * offset;
             }
 
             return index;
@@ -121,19 +191,25 @@ public static nint ComputeLinearIndex(ReadOnlySpan<NIndex> indexes, ReadOnlySpan
             return index;
         }
 
-        public static nint ComputeMaxElementCount(ReadOnlySpan<nint> strides, ReadOnlySpan<nint> lengths)
+        public static void ValidateStrides(ReadOnlySpan<nint> strides, ReadOnlySpan<nint> lengths)
         {
             Debug.Assert(strides.Length == lengths.Length);
 
-            nint index = 0;
-            for (int i = 0; i < lengths.Length; i++)
+            if (strides.Length == 0)
+                return;
+
+            if (strides[lengths.Length - 1] < 0)
+                ThrowHelper.ThrowArgument_StrideLessThan0();
+
+            for (int i = lengths.Length - 1; i > 0; i--)
             {
-                if (strides[i] < 0)
+                if (strides[i - 1] == 0)
+                    continue;
+                else if (strides[i - 1] < 0)
+                    ThrowHelper.ThrowArgument_StrideLessThan0();
+                if (strides[i - 1] < strides[i] * lengths[i])
                     ThrowHelper.ThrowArgument_StrideLessThan0();
-                index *= strides[i] * lengths[i];
             }
-
-            return index;
         }
 
         /// <summary>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs b/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs
index 520de436ac5f3..8cb4d7ab957dd 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs
@@ -121,6 +121,12 @@ public static void ThrowArgument_1DTensorRequired(string? paramNames)
             throw new ArgumentException(SR.ThrowArgument_1DTensorRequired, paramNames);
         }
 
+        [DoesNotReturn]
+        public static void ThrowArgument_2DTensorRequired(string? paramNames)
+        {
+            throw new ArgumentException(SR.Argument_2DTensorRequired, paramNames);
+        }
+
         [DoesNotReturn]
         public static void ThrowArgument_IncorrectNumberOfFilterItems(string? paramNames)
         {
@@ -202,7 +208,13 @@ public static void ThrowArgument_InvalidStridesAndLengths()
         [DoesNotReturn]
         public static void ThrowArgument_StrideLessThan0()
         {
-            throw new ArgumentException(SR.ThrowArgument_StrideLessThan0);
+            throw new ArgumentOutOfRangeException(SR.ThrowArgument_StrideLessThan0);
+        }
+
+        [DoesNotReturn]
+        internal static void ThrowArgument_IncompatibleDimensions(nint leftDim, nint rightDim)
+        {
+            throw new ArgumentException(SR.Format(SR.Argument_IncompatibleDimensions, leftDim, rightDim));
         }
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/tests/Helpers.cs b/src/libraries/System.Numerics.Tensors/tests/Helpers.cs
index 052d22d0e1837..d2e213e937264 100644
--- a/src/libraries/System.Numerics.Tensors/tests/Helpers.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/Helpers.cs
@@ -14,6 +14,7 @@ public static class Helpers
         public static IEnumerable<int> TensorLengthsIncluding0 => Enumerable.Range(0, 257);
 
         public static IEnumerable<int> TensorLengths => Enumerable.Range(1, 256);
+        public static IEnumerable<nint[]> TensorShapes => [[1], [2], [10], [1,1], [1,2], [2,2], [5, 5], [2, 2, 2], [5, 5, 5], [3, 3, 3, 3], [4, 4, 4, 4, 4]];
 
         // Tolerances taken from testing in the scalar math routines:
         // cf. https://github.com/dotnet/runtime/blob/89f7ad3b276fb0b48f20cb4e8408bdce85c2b415/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Math.cs
diff --git a/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs b/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs
index 918f011c3c16b..70161522e4882 100644
--- a/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -12,6 +13,745 @@ namespace System.Numerics.Tensors.Tests
 {
     public class ReadOnlyTensorSpanTests
     {
+        [Fact]
+        public static void ReadOnlyTensorSpanSystemArrayConstructorTests()
+        {
+            // Make sure basic T[,] constructor works
+            int[,] a = new int[,] { { 91, 92, -93, 94 } };
+            scoped ReadOnlyTensorSpan<int> spanInt = new ReadOnlyTensorSpan<int>(a);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(4, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[0, 2]);
+            Assert.Equal(94, spanInt[0, 3]);
+
+            // Make sure null works
+            // Should be a tensor with 0 elements and Rank 0 and no strides or lengths
+            int[,] n = null;
+            spanInt = new ReadOnlyTensorSpan<int>(n);
+            Assert.Equal(0, spanInt.Rank);
+            Assert.Equal(0, spanInt.Lengths.Length);
+            Assert.Equal(0, spanInt.Strides.Length);
+
+            // Make sure empty array works
+            // Should be a Tensor with 0 elements but Rank 2 with dimension 0 length 0
+            int[,] b = { { } };
+            spanInt = new ReadOnlyTensorSpan<int>(b);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(0, spanInt.Lengths[1]);
+            Assert.Equal(0, spanInt.FlattenedLength);
+            Assert.Equal(0, spanInt.Strides[0]);
+            Assert.Equal(0, spanInt.Strides[1]);
+            // Make sure it still throws on index 0, 0
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                var spanInt = new ReadOnlyTensorSpan<int>(b);
+                var x = spanInt[0, 0];
+            });
+
+            // Make sure 2D array works
+            spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [2, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure can use only some of the array
+            spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [1, 2], default);
+                var x = spanInt[1, 1];
+            });
+
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [1, 2], default);
+                var x = spanInt[0, -1];
+            });
+
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [1, 2], default);
+                var x = spanInt[-1, 0];
+            });
+
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [1, 2], default);
+                var x = spanInt[1, 0];
+            });
+
+            // Make sure Index offset works correctly
+            spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 1], [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(92, spanInt[0, 0]);
+            Assert.Equal(-93, spanInt[0, 1]);
+
+            // Make sure Index offset works correctly
+            spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 2], [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+
+            // Make sure 2D array works with strides of all 0 and initial offset to loop over last element again
+            spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 3], [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure we catch that there aren't enough elements in the array for the lengths
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 3], [1, 2], default);
+            });
+
+            // Make sure 2D array works with basic strides
+            spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [2, 2], [2, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 to loop over first 2 elements again
+            spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(91, spanInt[1, 0]);
+            Assert.Equal(92, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 and initial offset to loop over last 2 elements again
+            spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 2], [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure strides can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [1, 2], [-1, 0]);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [1, 2], [0, -1]);
+            });
+
+            // Make sure lengths can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [-1, 2], []);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[0, 0], [1, -2], []);
+            });
+
+            // Make sure 2D array works with strides to hit element 0,0,2,2
+            spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[], [2, 2], [2, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(91, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(-93, spanInt[1, 1]);
+
+            // Make sure you can't overlap elements using strides
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[], [2, 2], [1, 1]);
+            });
+
+            a = new int[,] { { 91, 92 }, { -93, 94 } };
+            spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[1, 1], [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            //Make sure it works with NIndex
+            spanInt = new ReadOnlyTensorSpan<int>(a, (NIndex[])[1, 1], [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            //Make sure it works with NIndex
+            spanInt = new ReadOnlyTensorSpan<int>(a, (NIndex[])[^1, ^1], [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+        }
+
+        [Fact]
+        public static void ReadOnlyTensorSpanArrayConstructorTests()
+        {
+            // Make sure basic T[] constructor works
+            int[] a = { 91, 92, -93, 94 };
+            scoped ReadOnlyTensorSpan<int> spanInt = new ReadOnlyTensorSpan<int>(a);
+            Assert.Equal(1, spanInt.Rank);
+            Assert.Equal(4, spanInt.Lengths[0]);
+            Assert.Equal(91, spanInt[0]);
+            Assert.Equal(92, spanInt[1]);
+            Assert.Equal(-93, spanInt[2]);
+            Assert.Equal(94, spanInt[3]);
+
+            // Make sure null works
+            // Should be a tensor with 0 elements and Rank 0 and no strides or lengths
+            spanInt = new ReadOnlyTensorSpan<int>(null);
+            Assert.Equal(0, spanInt.Rank);
+            Assert.Equal(0, spanInt.Lengths.Length);
+            Assert.Equal(0, spanInt.Strides.Length);
+
+            // Make sure empty array works
+            // Should be a Tensor with 0 elements but Rank 1 with dimension 0 length 0
+            int[] b = { };
+            spanInt = new ReadOnlyTensorSpan<int>(b);
+            Assert.Equal(1, spanInt.Rank);
+            Assert.Equal(0, spanInt.Lengths[0]);
+            Assert.Equal(0, spanInt.FlattenedLength);
+            Assert.Equal(0, spanInt.Strides[0]);
+            // Make sure it still throws on index 0
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                var spanInt = new ReadOnlyTensorSpan<int>(b);
+                var x = spanInt[0];
+            });
+
+            // Make sure empty array works
+            // Should be a Tensor with 0 elements but Rank 1 with dimension 0 length 0
+            spanInt = new ReadOnlyTensorSpan<int>(b, 0, [], default);
+            Assert.Equal(1, spanInt.Rank);
+            Assert.Equal(0, spanInt.Lengths[0]);
+            Assert.Equal(0, spanInt.FlattenedLength);
+            Assert.Equal(0, spanInt.Strides[0]);
+
+            // Make sure 2D array works
+            spanInt = new ReadOnlyTensorSpan<int>(a, new Index(0), [2,2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0,0]);
+            Assert.Equal(92, spanInt[0,1]);
+            Assert.Equal(-93, spanInt[1,0]);
+            Assert.Equal(94, spanInt[1,1]);
+
+            // Make sure can use only some of the array
+            spanInt = new ReadOnlyTensorSpan<int>(a, new Index(0), [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, new Index(0), [1, 2], default);
+                var x = spanInt[1, 1];
+            });
+
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, new Index(0), [1, 2], default);
+                var x = spanInt[1, 0];
+            });
+
+            // Make sure Index offset works correctly
+            spanInt = new ReadOnlyTensorSpan<int>(a, new Index(1), [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(92, spanInt[0, 0]);
+            Assert.Equal(-93, spanInt[0, 1]);
+
+            // Make sure Index offset works correctly
+            spanInt = new ReadOnlyTensorSpan<int>(a, new Index(2), [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+
+            // Make sure we catch that there aren't enough elements in the array for the lengths
+            Assert.Throws<ArgumentException>(() => {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, new Index(3), [1, 2], default);
+            });
+
+            // Make sure 2D array works with basic strides
+            spanInt = new ReadOnlyTensorSpan<int>(a, new Index(0), [2, 2], [2, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 to loop over first 2 elements again
+            spanInt = new ReadOnlyTensorSpan<int>(a, new Index(0), [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(91, spanInt[1, 0]);
+            Assert.Equal(92, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 and initial offset to loop over last 2 elements again
+            spanInt = new ReadOnlyTensorSpan<int>(a, new Index(2), [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure 2D array works with strides of all 0 and initial offset to loop over last element again
+            spanInt = new ReadOnlyTensorSpan<int>(a, new Index(3), [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure strides can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, new Index(3), [1, 2], [-1, 0]);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, new Index(3), [1, 2], [0, -1]);
+            });
+
+            // Make sure lengths can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, new Index(3), [-1, 2], []);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, new Index(3), [1, -2], []);
+            });
+
+            // Make sure 2D array works with strides to hit element 0,0,2,2
+            spanInt = new ReadOnlyTensorSpan<int>(a, 0, [2, 2], [2, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(91, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(-93, spanInt[1, 1]);
+
+            // Make sure you can't overlap elements using strides
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, 0, [2, 2], [1, 1]);
+            });
+        }
+
+        [Fact]
+        public static void ReadOnlyTensorSpanSpanConstructorTests()
+        {
+            // Make sure basic T[] constructor works
+            Span<int> a = [ 91, 92, -93, 94 ];
+            scoped ReadOnlyTensorSpan<int> spanInt = new ReadOnlyTensorSpan<int>(a);
+            Assert.Equal(1, spanInt.Rank);
+            Assert.Equal(4, spanInt.Lengths[0]);
+            Assert.Equal(91, spanInt[0]);
+            Assert.Equal(92, spanInt[1]);
+            Assert.Equal(-93, spanInt[2]);
+            Assert.Equal(94, spanInt[3]);
+
+            // Make sure empty span works
+            // Should be a Tensor with 0 elements but Rank 1 with dimension 0 length 0
+            Span<int> b = [];
+            spanInt = new ReadOnlyTensorSpan<int>(b);
+            Assert.Equal(1, spanInt.Rank);
+            Assert.Equal(0, spanInt.Lengths[0]);
+            Assert.Equal(0, spanInt.FlattenedLength);
+            Assert.Equal(0, spanInt.Strides[0]);
+            // Make sure it still throws on index 0
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                Span<int> b = [];
+                var spanInt = new ReadOnlyTensorSpan<int>(b);
+                var x = spanInt[0];
+            });
+
+            // Make sure 2D array works
+            spanInt = new ReadOnlyTensorSpan<int>(a, [2, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure can use only some of the array
+            spanInt = new ReadOnlyTensorSpan<int>(a, [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new ReadOnlyTensorSpan<int>(a, [1, 2], default);
+                var x = spanInt[1, 1];
+            });
+
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new ReadOnlyTensorSpan<int>(a, [1, 2], default);
+                var x = spanInt[1, 0];
+            });
+
+            // Make sure Index offset works correctly
+            spanInt = new ReadOnlyTensorSpan<int>(a.Slice(1), [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(92, spanInt[0, 0]);
+            Assert.Equal(-93, spanInt[0, 1]);
+
+            // Make sure Index offset works correctly
+            spanInt = new ReadOnlyTensorSpan<int>(a.Slice(2), [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+
+            // Make sure we catch that there aren't enough elements in the array for the lengths
+            Assert.Throws<ArgumentException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new ReadOnlyTensorSpan<int>(a.Slice(3), [1, 2], default);
+            });
+
+            // Make sure 2D array works with basic strides
+            spanInt = new ReadOnlyTensorSpan<int>(a, [2, 2], [2, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 to loop over first 2 elements again
+            spanInt = new ReadOnlyTensorSpan<int>(a, [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(91, spanInt[1, 0]);
+            Assert.Equal(92, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 and initial offset to loop over last 2 elements again
+            spanInt = new ReadOnlyTensorSpan<int>(a.Slice(2), [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure 2D array works with strides of all 0 and initial offset to loop over last element again
+            spanInt = new ReadOnlyTensorSpan<int>(a.Slice(3), [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure strides can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new ReadOnlyTensorSpan<int>(a, [1, 2], [-1, 0]);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new ReadOnlyTensorSpan<int>(a, [1, 2], [0, -1]);
+            });
+
+            // Make sure lengths can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new ReadOnlyTensorSpan<int>(a, [-1, 2], []);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new ReadOnlyTensorSpan<int>(a, [1, -2], []);
+            });
+
+            // Make sure 2D array works with strides to hit element 0,0,2,2
+            spanInt = new ReadOnlyTensorSpan<int>(a, [2, 2], [2, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(91, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(-93, spanInt[1, 1]);
+
+            // Make sure you can't overlap elements using strides
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new ReadOnlyTensorSpan<int>(a, [2, 2], [1, 1]);
+            });
+        }
+
+        [Fact]
+        public static unsafe void ReadOnlyTensorSpanPointerConstructorTests()
+        {
+            // Make sure basic T[] constructor works
+            Span<int> a = [91, 92, -93, 94];
+            ReadOnlyTensorSpan<int> spanInt;
+            fixed (int* p = a)
+            {
+                spanInt = new ReadOnlyTensorSpan<int>(p, 4);
+                Assert.Equal(1, spanInt.Rank);
+                Assert.Equal(4, spanInt.Lengths[0]);
+                Assert.Equal(91, spanInt[0]);
+                Assert.Equal(92, spanInt[1]);
+                Assert.Equal(-93, spanInt[2]);
+                Assert.Equal(94, spanInt[3]);
+            }
+
+            // Make sure empty span works
+            // Should be a Tensor with 0 elements but Rank 1 with dimension 0 length 0
+            Span<int> b = [];
+            fixed (int* p = b)
+            {
+                spanInt = new ReadOnlyTensorSpan<int>(p, 0);
+                Assert.Equal(1, spanInt.Rank);
+                Assert.Equal(0, spanInt.Lengths[0]);
+                Assert.Equal(0, spanInt.FlattenedLength);
+                Assert.Equal(0, spanInt.Strides[0]);
+                // Make sure it still throws on index 0
+                Assert.Throws<IndexOutOfRangeException>(() =>
+                {
+                    Span<int> b = [];
+                    fixed (int* p = b)
+                    {
+                        var spanInt = new ReadOnlyTensorSpan<int>(p, 0);
+                        var x = spanInt[0];
+                    }
+                });
+            }
+
+
+            // Make sure 2D array works
+            fixed (int* p = a)
+            {
+                spanInt = new ReadOnlyTensorSpan<int>(p, 4, [2, 2], default);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(91, spanInt[0, 0]);
+                Assert.Equal(92, spanInt[0, 1]);
+                Assert.Equal(-93, spanInt[1, 0]);
+                Assert.Equal(94, spanInt[1, 1]);
+
+                // Make sure can use only some of the array
+                spanInt = new ReadOnlyTensorSpan<int>(p, 4, [1, 2], default);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(1, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(91, spanInt[0, 0]);
+                Assert.Equal(92, spanInt[0, 1]);
+                Assert.Throws<IndexOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new ReadOnlyTensorSpan<int>(p, 4, [1, 2], default);
+                        var x = spanInt[1, 1];
+                    }
+                });
+
+                Assert.Throws<IndexOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new ReadOnlyTensorSpan<int>(p, 4, [1, 2], default);
+                        var x = spanInt[1, 0];
+                    }
+                });
+
+                // Make sure Index offset works correctly
+                spanInt = new ReadOnlyTensorSpan<int>(p + 1, 3, [1, 2], default);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(1, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(92, spanInt[0, 0]);
+                Assert.Equal(-93, spanInt[0, 1]);
+
+                // Make sure Index offset works correctly
+                spanInt = new ReadOnlyTensorSpan<int>(p + 2, 2, [1, 2], default);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(1, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(-93, spanInt[0, 0]);
+                Assert.Equal(94, spanInt[0, 1]);
+
+                // Make sure we catch that there aren't enough elements in the array for the lengths
+                Assert.Throws<ArgumentException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new ReadOnlyTensorSpan<int>(p + 3, 1, [1, 2], default);
+                    }
+                });
+
+                // Make sure 2D array works with basic strides
+                spanInt = new ReadOnlyTensorSpan<int>(p, 4, [2, 2], [2, 1]);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(91, spanInt[0, 0]);
+                Assert.Equal(92, spanInt[0, 1]);
+                Assert.Equal(-93, spanInt[1, 0]);
+                Assert.Equal(94, spanInt[1, 1]);
+
+                // Make sure 2D array works with stride of 0 to loop over first 2 elements again
+                spanInt = new ReadOnlyTensorSpan<int>(p, 4, [2, 2], [0, 1]);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(91, spanInt[0, 0]);
+                Assert.Equal(92, spanInt[0, 1]);
+                Assert.Equal(91, spanInt[1, 0]);
+                Assert.Equal(92, spanInt[1, 1]);
+
+                // Make sure 2D array works with stride of 0 and initial offset to loop over last 2 elements again
+                spanInt = new ReadOnlyTensorSpan<int>(p + 2, 2, [2, 2], [0, 1]);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(-93, spanInt[0, 0]);
+                Assert.Equal(94, spanInt[0, 1]);
+                Assert.Equal(-93, spanInt[1, 0]);
+                Assert.Equal(94, spanInt[1, 1]);
+
+                // Make sure 2D array works with strides of all 0 and initial offset to loop over last element again
+                spanInt = new ReadOnlyTensorSpan<int>(p + 3, 1, [2, 2], [0, 0]);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(94, spanInt[0, 0]);
+                Assert.Equal(94, spanInt[0, 1]);
+                Assert.Equal(94, spanInt[1, 0]);
+                Assert.Equal(94, spanInt[1, 1]);
+
+                // Make sure strides can't be negative
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new ReadOnlyTensorSpan<int>(p, 4, [1, 2], [-1, 0]);
+                    }
+                });
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new ReadOnlyTensorSpan<int>(p, 4, [1, 2], [0, -1]);
+                    }
+                });
+
+                // Make sure lengths can't be negative
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new ReadOnlyTensorSpan<int>(p, 4, [-1, 2], []);
+                    }
+                });
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new ReadOnlyTensorSpan<int>(p, 4, [1, -2], []);
+                    }
+                });
+
+                // Make sure can't use negative data length amount
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new ReadOnlyTensorSpan<int>(p, -1, [1, -2], []);
+                    }
+                });
+
+                // Make sure 2D array works with strides to hit element 0,0,2,2
+                spanInt = new ReadOnlyTensorSpan<int>(p, 4, [2, 2], [2, 0]);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(91, spanInt[0, 0]);
+                Assert.Equal(91, spanInt[0, 1]);
+                Assert.Equal(-93, spanInt[1, 0]);
+                Assert.Equal(-93, spanInt[1, 1]);
+
+                // Make sure you can't overlap elements using strides
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new ReadOnlyTensorSpan<int>(p, 4, [2, 2], [1, 1]);
+                    }
+                });
+            }
+        }
+
         [Fact]
         public static void IntArrayAsReadOnlyTensorSpan()
         {
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs
index 911dc6805588a..3937cd4a94008 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs
@@ -1,26 +1,1031 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace System.Numerics.Tensors.Tests
 {
     public class TensorSpanTests
     {
+        #region TensorPrimitivesForwardsTests
+        private void FillTensor<T>(Span<T> span)
+            where T : INumberBase<T>
+        {
+            for (int i = 0; i < span.Length; i++)
+            {
+                span[i] = T.CreateChecked((Random.Shared.NextSingle() * 100) - 50);
+            }
+        }
+
+        private static nint CalculateTotalLength(ReadOnlySpan<nint> lengths)
+        {
+            if (lengths.IsEmpty)
+                return 0;
+            nint totalLength = 1;
+            for (int i = 0; i < lengths.Length; i++)
+            {
+                totalLength *= lengths[i];
+            }
+
+            return totalLength;
+        }
+
+        public delegate void TensorPrimitivesSpanInSpanOut<T>(ReadOnlySpan<T> input, Span<T> output);
+        public delegate TensorSpan<T> TensorSpanInSpanOut<T>(TensorSpan<T> input);
+
+        public static IEnumerable<object[]> SpanInSpanOutData()
+        {
+            yield return Create<float>(TensorPrimitives.Abs<float>, TensorSpan.Abs);
+            yield return Create<float>(TensorPrimitives.Abs, TensorSpan.AbsInPlace);
+            yield return Create<float>(TensorPrimitives.Acos, TensorSpan.Acos);
+            yield return Create<float>(TensorPrimitives.Acos, TensorSpan.AcosInPlace);
+            yield return Create<float>(TensorPrimitives.Acosh, TensorSpan.Acosh);
+            yield return Create<float>(TensorPrimitives.Acosh, TensorSpan.AcoshInPlace);
+            yield return Create<float>(TensorPrimitives.AcosPi, TensorSpan.AcosPi);
+            yield return Create<float>(TensorPrimitives.AcosPi, TensorSpan.AcosPiInPlace);
+            yield return Create<float>(TensorPrimitives.Asin, TensorSpan.Asin);
+            yield return Create<float>(TensorPrimitives.Asin, TensorSpan.AsinInPlace);
+            yield return Create<float>(TensorPrimitives.Asinh, TensorSpan.Asinh);
+            yield return Create<float>(TensorPrimitives.Asinh, TensorSpan.AsinhInPlace);
+            yield return Create<float>(TensorPrimitives.AsinPi, TensorSpan.AsinPi);
+            yield return Create<float>(TensorPrimitives.AsinPi, TensorSpan.AsinPiInPlace);
+            yield return Create<float>(TensorPrimitives.Atan, TensorSpan.Atan);
+            yield return Create<float>(TensorPrimitives.Atan, TensorSpan.AtanInPlace);
+            yield return Create<float>(TensorPrimitives.Atanh, TensorSpan.Atanh);
+            yield return Create<float>(TensorPrimitives.Atanh, TensorSpan.AtanhInPlace);
+            yield return Create<float>(TensorPrimitives.AtanPi, TensorSpan.AtanPi);
+            yield return Create<float>(TensorPrimitives.AtanPi, TensorSpan.AtanPiInPlace);
+            yield return Create<float>(TensorPrimitives.Cbrt, TensorSpan.CubeRoot);
+            yield return Create<float>(TensorPrimitives.Cbrt, TensorSpan.CubeRootInPlace);
+            yield return Create<float>(TensorPrimitives.Ceiling, TensorSpan.Ceiling);
+            yield return Create<float>(TensorPrimitives.Ceiling, TensorSpan.CeilingInPlace);
+            yield return Create<float>(TensorPrimitives.Cos, TensorSpan.Cos);
+            yield return Create<float>(TensorPrimitives.Cos, TensorSpan.CosInPlace);
+            yield return Create<float>(TensorPrimitives.Cosh, TensorSpan.Cosh);
+            yield return Create<float>(TensorPrimitives.Cosh, TensorSpan.CoshInPlace);
+            yield return Create<float>(TensorPrimitives.CosPi, TensorSpan.CosPi);
+            yield return Create<float>(TensorPrimitives.CosPi, TensorSpan.CosPiInPlace);
+            yield return Create<float>(TensorPrimitives.DegreesToRadians, TensorSpan.DegreesToRadians);
+            yield return Create<float>(TensorPrimitives.DegreesToRadians, TensorSpan.DegreesToRadiansInPlace);
+            yield return Create<float>(TensorPrimitives.Exp, TensorSpan.Exp);
+            yield return Create<float>(TensorPrimitives.Exp, TensorSpan.ExpInPlace);
+            yield return Create<float>(TensorPrimitives.Exp10, TensorSpan.Exp10);
+            yield return Create<float>(TensorPrimitives.Exp10, TensorSpan.Exp10InPlace);
+            yield return Create<float>(TensorPrimitives.Exp10M1, TensorSpan.Exp10M1);
+            yield return Create<float>(TensorPrimitives.Exp10M1, TensorSpan.Exp10M1InPlace);
+            yield return Create<float>(TensorPrimitives.Exp2, TensorSpan.Exp2);
+            yield return Create<float>(TensorPrimitives.Exp2, TensorSpan.Exp2InPlace);
+            yield return Create<float>(TensorPrimitives.Exp2M1, TensorSpan.Exp2M1);
+            yield return Create<float>(TensorPrimitives.Exp2M1, TensorSpan.Exp2M1InPlace);
+            yield return Create<float>(TensorPrimitives.ExpM1, TensorSpan.ExpM1);
+            yield return Create<float>(TensorPrimitives.ExpM1, TensorSpan.ExpM1InPlace);
+            yield return Create<float>(TensorPrimitives.Floor, TensorSpan.Floor);
+            yield return Create<float>(TensorPrimitives.Floor, TensorSpan.FloorInPlace);
+            yield return Create<int>(TensorPrimitives.LeadingZeroCount, TensorSpan.LeadingZeroCount);
+            yield return Create<int>(TensorPrimitives.LeadingZeroCount, TensorSpan.LeadingZeroCount);
+            yield return Create<float>(TensorPrimitives.Log, TensorSpan.Log);
+            yield return Create<float>(TensorPrimitives.Log, TensorSpan.LogInPlace);
+            yield return Create<float>(TensorPrimitives.Log10, TensorSpan.Log10);
+            yield return Create<float>(TensorPrimitives.Log10, TensorSpan.Log10InPlace);
+            yield return Create<float>(TensorPrimitives.Log10P1, TensorSpan.Log10P1);
+            yield return Create<float>(TensorPrimitives.Log10P1, TensorSpan.Log10P1InPlace);
+            yield return Create<float>(TensorPrimitives.Log2, TensorSpan.Log2);
+            yield return Create<float>(TensorPrimitives.Log2, TensorSpan.Log2InPlace);
+            yield return Create<float>(TensorPrimitives.Log2P1, TensorSpan.Log2P1);
+            yield return Create<float>(TensorPrimitives.Log2P1, TensorSpan.Log2P1InPlace);
+            yield return Create<float>(TensorPrimitives.LogP1, TensorSpan.LogP1);
+            yield return Create<float>(TensorPrimitives.LogP1, TensorSpan.LogP1InPlace);
+            yield return Create<float>(TensorPrimitives.Negate, TensorSpan.Negate);
+            yield return Create<float>(TensorPrimitives.Negate, TensorSpan.NegateInPlace);
+            yield return Create<float>(TensorPrimitives.OnesComplement, TensorSpan.OnesComplement);
+            yield return Create<float>(TensorPrimitives.OnesComplement, TensorSpan.OnesComplementInPlace);
+            yield return Create<int>(TensorPrimitives.PopCount, TensorSpan.PopCount);
+            yield return Create<int>(TensorPrimitives.PopCount, TensorSpan.PopCountInPlace);
+            yield return Create<float>(TensorPrimitives.RadiansToDegrees, TensorSpan.RadiansToDegrees);
+            yield return Create<float>(TensorPrimitives.RadiansToDegrees, TensorSpan.RadiansToDegreesInPlace);
+            yield return Create<float>(TensorPrimitives.Reciprocal, TensorSpan.Reciprocal);
+            yield return Create<float>(TensorPrimitives.Reciprocal, TensorSpan.ReciprocalInPlace);
+            yield return Create<float>(TensorPrimitives.Round, TensorSpan.Round);
+            yield return Create<float>(TensorPrimitives.Round, TensorSpan.RoundInPlace);
+            yield return Create<float>(TensorPrimitives.Sigmoid, TensorSpan.Sigmoid);
+            yield return Create<float>(TensorPrimitives.Sigmoid, TensorSpan.SigmoidInPlace);
+            yield return Create<float>(TensorPrimitives.Sin, TensorSpan.Sin);
+            yield return Create<float>(TensorPrimitives.Sin, TensorSpan.SinInPlace);
+            yield return Create<float>(TensorPrimitives.Sinh, TensorSpan.Sinh);
+            yield return Create<float>(TensorPrimitives.Sinh, TensorSpan.SinhInPlace);
+            yield return Create<float>(TensorPrimitives.SinPi, TensorSpan.SinPi);
+            yield return Create<float>(TensorPrimitives.SinPi, TensorSpan.SinPiInPlace);
+            yield return Create<float>(TensorPrimitives.SoftMax, TensorSpan.SoftMax);
+            yield return Create<float>(TensorPrimitives.SoftMax, TensorSpan.SoftMaxInPlace);
+            yield return Create<float>(TensorPrimitives.Sqrt, TensorSpan.Sqrt);
+            yield return Create<float>(TensorPrimitives.Sqrt, TensorSpan.SqrtInPlace);
+            yield return Create<float>(TensorPrimitives.Tan, TensorSpan.Tan);
+            yield return Create<float>(TensorPrimitives.Tan, TensorSpan.TanInPlace);
+            yield return Create<float>(TensorPrimitives.Tanh, TensorSpan.Tanh);
+            yield return Create<float>(TensorPrimitives.Tanh, TensorSpan.TanhInPlace);
+            yield return Create<float>(TensorPrimitives.TanPi, TensorSpan.TanPi);
+            yield return Create<float>(TensorPrimitives.TanPi, TensorSpan.TanPiInPlace);
+            yield return Create<float>(TensorPrimitives.Truncate, TensorSpan.Truncate);
+            yield return Create<float>(TensorPrimitives.Truncate, TensorSpan.TruncateInPlace);
+
+            static object[] Create<T>(TensorPrimitivesSpanInSpanOut<T> tensorPrimitivesMethod, TensorSpanInSpanOut<T> tensorOperation)
+                => new object[] { tensorPrimitivesMethod, tensorOperation };
+        }
+
+        [Theory, MemberData(nameof(SpanInSpanOutData))]
+        public void TensorExtensionsSpanInSpanOut<T>(TensorPrimitivesSpanInSpanOut<T> tensorPrimitivesOperation, TensorSpanInSpanOut<T> tensorOperation)
+            where T : INumberBase<T>
+        {
+            Assert.All(Helpers.TensorShapes, tensorLength =>
+            {
+                nint length = CalculateTotalLength(tensorLength);
+                T[] data = new T[length];
+                T[] expectedOutput = new T[length];
+
+                FillTensor<T>(data);
+                TensorSpan<T> x = Tensor.Create<T>(data, tensorLength, []);
+                tensorPrimitivesOperation((ReadOnlySpan<T>)data, expectedOutput);
+                TensorSpan<T> results = tensorOperation(x);
+
+                Assert.Equal(tensorLength, results.Lengths);
+                nint[] startingIndex = new nint[tensorLength.Length];
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref results[startingIndex], (int)length);
+
+                for (int i = 0; i < data.Length; i++)
+                {
+                    Assert.Equal(expectedOutput[i], span[i]);
+                }
+            });
+        }
+
+        public delegate T TensorPrimitivesSpanInTOut<T>(ReadOnlySpan<T> input);
+        public delegate T TensorSpanInTOut<T>(TensorSpan<T> input);
+        public static IEnumerable<object[]> SpanInFloatOutData()
+        {
+            yield return Create<float>(TensorPrimitives.Max, TensorSpan.Max);
+            yield return Create<float>(TensorPrimitives.MaxMagnitude, TensorSpan.MaxMagnitude);
+            yield return Create<float>(TensorPrimitives.MaxNumber, TensorSpan.MaxNumber);
+            yield return Create<float>(TensorPrimitives.Min, TensorSpan.Min);
+            yield return Create<float>(TensorPrimitives.MinMagnitude, TensorSpan.MinMagnitude);
+            yield return Create<float>(TensorPrimitives.MinNumber, TensorSpan.MinNumber);
+            yield return Create<float>(TensorPrimitives.Norm, TensorSpan.Norm);
+            yield return Create<float>(TensorPrimitives.Product, TensorSpan.Product);
+            yield return Create<float>(TensorPrimitives.Sum, TensorSpan.Sum);
+
+            static object[] Create<T>(TensorPrimitivesSpanInTOut<T> tensorPrimitivesMethod, TensorSpanInTOut<T> tensorOperation)
+                => new object[] { tensorPrimitivesMethod, tensorOperation };
+        }
+
+        [Theory, MemberData(nameof(SpanInFloatOutData))]
+        public void TensorExtensionsSpanInTOut<T>(TensorPrimitivesSpanInTOut<T> tensorPrimitivesOperation, TensorSpanInTOut<T> tensorOperation)
+            where T : INumberBase<T>
+        {
+            Assert.All(Helpers.TensorShapes, tensorLength =>
+            {
+                nint length = CalculateTotalLength(tensorLength);
+                T[] data = new T[length];
+
+                FillTensor<T>(data);
+                Tensor<T> x = Tensor.Create<T>(data, tensorLength, []);
+                T expectedOutput = tensorPrimitivesOperation((ReadOnlySpan<T>)data);
+                T results = tensorOperation(x);
+
+                Assert.Equal(expectedOutput, results);
+            });
+        }
+
+        public delegate void TensorPrimitivesTwoSpanInSpanOut<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo, Span<T> output);
+        public delegate TensorSpan<T> TensorTwoSpanInSpanOut<T>(TensorSpan<T> input, TensorSpan<T> inputTwo);
+        public static IEnumerable<object[]> TwoSpanInSpanOutData()
+        {
+            yield return Create<float>(TensorPrimitives.Add, TensorSpan.Add);
+            yield return Create<float>(TensorPrimitives.Add, TensorSpan.AddInPlace);
+            yield return Create<float>(TensorPrimitives.Atan2, TensorSpan.Atan2);
+            yield return Create<float>(TensorPrimitives.Atan2, TensorSpan.Atan2InPlace);
+            yield return Create<float>(TensorPrimitives.Atan2Pi, TensorSpan.Atan2Pi);
+            yield return Create<float>(TensorPrimitives.Atan2Pi, TensorSpan.Atan2PiInPlace);
+            yield return Create<float>(TensorPrimitives.CopySign, TensorSpan.CopySign);
+            yield return Create<float>(TensorPrimitives.CopySign, TensorSpan.CopySignInPlace);
+            yield return Create<float>(TensorPrimitives.Divide, TensorSpan.Divide);
+            yield return Create<float>(TensorPrimitives.Divide, TensorSpan.DivideInPlace);
+            yield return Create<float>(TensorPrimitives.Hypot, TensorSpan.Hypotenuse);
+            yield return Create<float>(TensorPrimitives.Hypot, TensorSpan.HypotenuseInPlace);
+            yield return Create<float>(TensorPrimitives.Ieee754Remainder, TensorSpan.Ieee754Remainder);
+            yield return Create<float>(TensorPrimitives.Ieee754Remainder, TensorSpan.Ieee754RemainderInPlace);
+            yield return Create<float>(TensorPrimitives.Multiply, TensorSpan.Multiply);
+            yield return Create<float>(TensorPrimitives.Multiply, TensorSpan.MultiplyInPlace);
+            yield return Create<float>(TensorPrimitives.Pow, TensorSpan.Pow);
+            yield return Create<float>(TensorPrimitives.Pow, TensorSpan.PowInPlace);
+            yield return Create<float>(TensorPrimitives.Subtract, TensorSpan.Subtract);
+            yield return Create<float>(TensorPrimitives.Subtract, TensorSpan.SubtractInPlace);
+
+            static object[] Create<T>(TensorPrimitivesTwoSpanInSpanOut<T> tensorPrimitivesMethod, TensorTwoSpanInSpanOut<T> tensorOperation)
+                => new object[] { tensorPrimitivesMethod, tensorOperation };
+        }
+
+        [Theory, MemberData(nameof(TwoSpanInSpanOutData))]
+        public void TensorExtensionsTwoSpanInSpanOut<T>(TensorPrimitivesTwoSpanInSpanOut<T> tensorPrimitivesOperation, TensorTwoSpanInSpanOut<T> tensorOperation)
+            where T : INumberBase<T>
+        {
+            Assert.All(Helpers.TensorShapes, tensorLength =>
+            {
+                nint length = CalculateTotalLength(tensorLength);
+                T[] data1 = new T[length];
+                T[] data2 = new T[length];
+                T[] expectedOutput = new T[length];
+
+                FillTensor<T>(data1);
+                FillTensor<T>(data2);
+                TensorSpan<T> x = Tensor.Create<T>(data1, tensorLength, []);
+                TensorSpan<T> y = Tensor.Create<T>(data2, tensorLength, []);
+                tensorPrimitivesOperation((ReadOnlySpan<T>)data1, data2, expectedOutput);
+                TensorSpan<T> results = tensorOperation(x, y);
+
+                Assert.Equal(tensorLength, results.Lengths);
+                nint[] startingIndex = new nint[tensorLength.Length];
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref results[startingIndex], (int)length);
+
+                for (int i = 0; i < data1.Length; i++)
+                {
+                    Assert.Equal(expectedOutput[i], span[i]);
+                }
+            });
+        }
+
+        public delegate T TensorPrimitivesTwoSpanInTOut<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo);
+        public delegate T TensorTwoSpanInTOut<T>(TensorSpan<T> input, TensorSpan<T> inputTwo);
+        public static IEnumerable<object[]> TwoSpanInFloatOutData()
+        {
+            yield return Create<float>(TensorPrimitives.Distance, TensorSpan.Distance);
+            yield return Create<float>(TensorPrimitives.Dot, TensorSpan.Dot);
+
+            static object[] Create<T>(TensorPrimitivesTwoSpanInTOut<T> tensorPrimitivesMethod, TensorTwoSpanInTOut<T> tensorOperation)
+                => new object[] { tensorPrimitivesMethod, tensorOperation };
+        }
+
+        [Theory, MemberData(nameof(TwoSpanInFloatOutData))]
+        public void TensorExtensionsTwoSpanInFloatOut<T>(TensorPrimitivesTwoSpanInTOut<T> tensorPrimitivesOperation, TensorTwoSpanInTOut<T> tensorOperation)
+            where T : INumberBase<T>
+        {
+            Assert.All(Helpers.TensorShapes, tensorLength =>
+            {
+                nint length = CalculateTotalLength(tensorLength);
+                T[] data1 = new T[length];
+                T[] data2 = new T[length];
+
+                FillTensor<T>(data1);
+                FillTensor<T>(data2);
+                TensorSpan<T> x = Tensor.Create<T>(data1, tensorLength, []);
+                TensorSpan<T> y = Tensor.Create<T>(data2, tensorLength, []);
+                T expectedOutput = tensorPrimitivesOperation((ReadOnlySpan<T>)data1, data2);
+                T results = tensorOperation(x, y);
+
+                Assert.Equal(expectedOutput, results);
+            });
+        }
+
+        #endregion
+
         [Fact]
-        public static void ConstructorTests()
+        public static void TensorSpanSystemArrayConstructorTests()
         {
-            int[] a = [1, 2, 3];
-            TensorSpan<int> span = new TensorSpan<int>(a, 0, [3, 3], [0, 1]);
+            // Make sure basic T[,] constructor works
+            int[,] a = new int[,] { { 91, 92, -93, 94 } };
+            scoped TensorSpan<int> spanInt = new TensorSpan<int>(a);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(4, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[0, 2]);
+            Assert.Equal(94, spanInt[0, 3]);
+
+            // Make sure null works
+            // Should be a tensor with 0 elements and Rank 0 and no strides or lengths
+            int[,] n = null;
+            spanInt = new TensorSpan<int>(n);
+            Assert.Equal(0, spanInt.Rank);
+            Assert.Equal(0, spanInt.Lengths.Length);
+            Assert.Equal(0, spanInt.Strides.Length);
+
+            // Make sure empty array works
+            // Should be a Tensor with 0 elements but Rank 2 with dimension 0 length 0
+            int[,] b = { { } };
+            spanInt = new TensorSpan<int>(b);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(0, spanInt.Lengths[1]);
+            Assert.Equal(0, spanInt.FlattenedLength);
+            Assert.Equal(0, spanInt.Strides[0]);
+            Assert.Equal(0, spanInt.Strides[1]);
+            // Make sure it still throws on index 0, 0
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                var spanInt = new TensorSpan<int>(b);
+                var x = spanInt[0, 0];
+            });
 
+            // Make sure 2D array works
+            spanInt = new TensorSpan<int>(a, (int[])[0, 0], [2, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
 
+            // Make sure can use only some of the array
+            spanInt = new TensorSpan<int>(a, (int[])[0, 0], [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var spanInt = new TensorSpan<int>(a, (int[])[0, 0], [1, 2], default);
+                var x = spanInt[1, 1];
+            });
+
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var spanInt = new TensorSpan<int>(a, (int[])[0, 0], [1, 2], default);
+                var x = spanInt[0, -1];
+            });
+
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var spanInt = new TensorSpan<int>(a, (int[])[0, 0], [1, 2], default);
+                var x = spanInt[-1, 0];
+            });
 
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var spanInt = new TensorSpan<int>(a, (int[])[0, 0], [1, 2], default);
+                var x = spanInt[1, 0];
+            });
+
+            // Make sure Index offset works correctly
+            spanInt = new TensorSpan<int>(a, (int[])[0, 1], [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(92, spanInt[0, 0]);
+            Assert.Equal(-93, spanInt[0, 1]);
+
+            // Make sure Index offset works correctly
+            spanInt = new TensorSpan<int>(a, (int[])[0, 2], [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+
+            // Make sure 2D array works with strides of all 0 and initial offset to loop over last element again
+            spanInt = new TensorSpan<int>(a, (int[])[0, 3], [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure we catch that there aren't enough elements in the array for the lengths
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new TensorSpan<int>(a, (int[])[0, 3], [1, 2], default);
+            });
+
+            // Make sure 2D array works with basic strides
+            spanInt = new TensorSpan<int>(a, (int[])[0, 0], [2, 2], [2, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 to loop over first 2 elements again
+            spanInt = new TensorSpan<int>(a, (int[])[0, 0], [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(91, spanInt[1, 0]);
+            Assert.Equal(92, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 and initial offset to loop over last 2 elements again
+            spanInt = new TensorSpan<int>(a, (int[])[0, 2], [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure strides can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new TensorSpan<int>(a, (int[])[0, 0], [1, 2], [-1, 0]);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new TensorSpan<int>(a, (int[])[0, 0], [1, 2], [0, -1]);
+            });
+
+            // Make sure lengths can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new TensorSpan<int>(a, (int[])[0, 0], [-1, 2], []);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new TensorSpan<int>(a, (int[])[0, 0], [1, -2], []);
+            });
+
+            // Make sure 2D array works with strides to hit element 0,0,2,2
+            spanInt = new TensorSpan<int>(a, (int[])[], [2, 2], [2, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(91, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(-93, spanInt[1, 1]);
+
+            // Make sure you can't overlap elements using strides
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                var spanInt = new TensorSpan<int>(a, (int[])[], [2, 2], [1, 1]);
+            });
+
+            a = new int[,] { { 91, 92 }, { -93, 94 } };
+            spanInt = new TensorSpan<int>(a, (int[])[1, 1], [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            //Make sure it works with NIndex
+            spanInt = new TensorSpan<int>(a, (NIndex[])[1, 1], [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            //Make sure it works with NIndex
+            spanInt = new TensorSpan<int>(a, (NIndex[])[^1, ^1], [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+        }
+
+        [Fact]
+        public static void TensorSpanArrayConstructorTests()
+        {
+            // Make sure basic T[] constructor works
+            int[] a = { 91, 92, -93, 94 };
+            scoped TensorSpan<int> spanInt = new TensorSpan<int>(a);
+            Assert.Equal(1, spanInt.Rank);
+            Assert.Equal(4, spanInt.Lengths[0]);
+            Assert.Equal(91, spanInt[0]);
+            Assert.Equal(92, spanInt[1]);
+            Assert.Equal(-93, spanInt[2]);
+            Assert.Equal(94, spanInt[3]);
+
+            // Make sure null works
+            // Should be a tensor with 0 elements and Rank 0 and no strides or lengths
+            spanInt = new TensorSpan<int>(null);
+            Assert.Equal(0, spanInt.Rank);
+            Assert.Equal(0, spanInt.Lengths.Length);
+            Assert.Equal(0, spanInt.Strides.Length);
+
+            // Make sure empty array works
+            // Should be a Tensor with 0 elements but Rank 1 with dimension 0 length 0
+            int[] b = { };
+            spanInt = new TensorSpan<int>(b);
+            Assert.Equal(1, spanInt.Rank);
+            Assert.Equal(0, spanInt.Lengths[0]);
+            Assert.Equal(0, spanInt.FlattenedLength);
+            Assert.Equal(0, spanInt.Strides[0]);
+            // Make sure it still throws on index 0
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                var spanInt = new TensorSpan<int>(b);
+                var x = spanInt[0];
+            });
+
+            // Make sure empty array works
+            // Should be a Tensor with 0 elements but Rank 1 with dimension 0 length 0
+            spanInt = new TensorSpan<int>(b, 0, [], default);
+            Assert.Equal(1, spanInt.Rank);
+            Assert.Equal(0, spanInt.Lengths[0]);
+            Assert.Equal(0, spanInt.FlattenedLength);
+            Assert.Equal(0, spanInt.Strides[0]);
+
+            // Make sure 2D array works
+            spanInt = new TensorSpan<int>(a, new Index(0), [2, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure can use only some of the array
+            spanInt = new TensorSpan<int>(a, new Index(0), [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                var spanInt = new TensorSpan<int>(a, new Index(0), [1, 2], default);
+                var x = spanInt[1, 1];
+            });
+
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                var spanInt = new TensorSpan<int>(a, new Index(0), [1, 2], default);
+                var x = spanInt[1, 0];
+            });
+
+            // Make sure Index offset works correctly
+            spanInt = new TensorSpan<int>(a, new Index(1), [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(92, spanInt[0, 0]);
+            Assert.Equal(-93, spanInt[0, 1]);
+
+            // Make sure Index offset works correctly
+            spanInt = new TensorSpan<int>(a, new Index(2), [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+
+            // Make sure we catch that there aren't enough elements in the array for the lengths
+            Assert.Throws<ArgumentException>(() => {
+                var spanInt = new TensorSpan<int>(a, new Index(3), [1, 2], default);
+            });
+
+            // Make sure 2D array works with basic strides
+            spanInt = new TensorSpan<int>(a, new Index(0), [2, 2], [2, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 to loop over first 2 elements again
+            spanInt = new TensorSpan<int>(a, new Index(0), [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(91, spanInt[1, 0]);
+            Assert.Equal(92, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 and initial offset to loop over last 2 elements again
+            spanInt = new TensorSpan<int>(a, new Index(2), [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure 2D array works with strides of all 0 and initial offset to loop over last element again
+            spanInt = new TensorSpan<int>(a, new Index(3), [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure strides can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new TensorSpan<int>(a, new Index(3), [1, 2], [-1, 0]);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new TensorSpan<int>(a, new Index(3), [1, 2], [0, -1]);
+            });
+
+            // Make sure lengths can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new TensorSpan<int>(a, new Index(3), [-1, 2], []);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new TensorSpan<int>(a, new Index(3), [1, -2], []);
+            });
+
+            // Make sure 2D array works with strides to hit element 0,0,2,2
+            spanInt = new TensorSpan<int>(a, 0, [2, 2], [2, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(91, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(-93, spanInt[1, 1]);
+
+            // Make sure you can't overlap elements using strides
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new TensorSpan<int>(a, 0, [2, 2], [1, 1]);
+            });
+        }
+
+        [Fact]
+        public static void TensorSpanSpanConstructorTests()
+        {
+            // Make sure basic T[] constructor works
+            Span<int> a = [91, 92, -93, 94];
+            scoped TensorSpan<int> spanInt = new TensorSpan<int>(a);
+            Assert.Equal(1, spanInt.Rank);
+            Assert.Equal(4, spanInt.Lengths[0]);
+            Assert.Equal(91, spanInt[0]);
+            Assert.Equal(92, spanInt[1]);
+            Assert.Equal(-93, spanInt[2]);
+            Assert.Equal(94, spanInt[3]);
+
+            // Make sure empty span works
+            // Should be a Tensor with 0 elements but Rank 1 with dimension 0 length 0
+            Span<int> b = [];
+            spanInt = new TensorSpan<int>(b);
+            Assert.Equal(1, spanInt.Rank);
+            Assert.Equal(0, spanInt.Lengths[0]);
+            Assert.Equal(0, spanInt.FlattenedLength);
+            Assert.Equal(0, spanInt.Strides[0]);
+            // Make sure it still throws on index 0
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                Span<int> b = [];
+                var spanInt = new TensorSpan<int>(b);
+                var x = spanInt[0];
+            });
+
+            // Make sure 2D array works
+            spanInt = new TensorSpan<int>(a, [2, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure can use only some of the array
+            spanInt = new TensorSpan<int>(a, [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new TensorSpan<int>(a, [1, 2], default);
+                var x = spanInt[1, 1];
+            });
+
+            Assert.Throws<IndexOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new TensorSpan<int>(a, [1, 2], default);
+                var x = spanInt[1, 0];
+            });
+
+            // Make sure Index offset works correctly
+            spanInt = new TensorSpan<int>(a.Slice(1), [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(92, spanInt[0, 0]);
+            Assert.Equal(-93, spanInt[0, 1]);
+
+            // Make sure Index offset works correctly
+            spanInt = new TensorSpan<int>(a.Slice(2), [1, 2], default);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(1, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+
+            // Make sure we catch that there aren't enough elements in the array for the lengths
+            Assert.Throws<ArgumentException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new TensorSpan<int>(a.Slice(3), [1, 2], default);
+            });
+
+            // Make sure 2D array works with basic strides
+            spanInt = new TensorSpan<int>(a, [2, 2], [2, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 to loop over first 2 elements again
+            spanInt = new TensorSpan<int>(a, [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(92, spanInt[0, 1]);
+            Assert.Equal(91, spanInt[1, 0]);
+            Assert.Equal(92, spanInt[1, 1]);
+
+            // Make sure 2D array works with stride of 0 and initial offset to loop over last 2 elements again
+            spanInt = new TensorSpan<int>(a.Slice(2), [2, 2], [0, 1]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(-93, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure 2D array works with strides of all 0 and initial offset to loop over last element again
+            spanInt = new TensorSpan<int>(a.Slice(3), [2, 2], [0, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(94, spanInt[0, 0]);
+            Assert.Equal(94, spanInt[0, 1]);
+            Assert.Equal(94, spanInt[1, 0]);
+            Assert.Equal(94, spanInt[1, 1]);
+
+            // Make sure strides can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new TensorSpan<int>(a, [1, 2], [-1, 0]);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new TensorSpan<int>(a, [1, 2], [0, -1]);
+            });
+
+            // Make sure lengths can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new TensorSpan<int>(a, [-1, 2], []);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new TensorSpan<int>(a, [1, -2], []);
+            });
+
+            // Make sure 2D array works with strides to hit element 0,0,2,2
+            spanInt = new TensorSpan<int>(a, [2, 2], [2, 0]);
+            Assert.Equal(2, spanInt.Rank);
+            Assert.Equal(2, spanInt.Lengths[0]);
+            Assert.Equal(2, spanInt.Lengths[1]);
+            Assert.Equal(91, spanInt[0, 0]);
+            Assert.Equal(91, spanInt[0, 1]);
+            Assert.Equal(-93, spanInt[1, 0]);
+            Assert.Equal(-93, spanInt[1, 1]);
+
+            // Make sure you can't overlap elements using strides
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var spanInt = new TensorSpan<int>(a, [2, 2], [1, 1]);
+            });
+        }
+
+        [Fact]
+        public static unsafe void TensorSpanPointerConstructorTests()
+        {
+            // Make sure basic T[] constructor works
+            Span<int> a = [91, 92, -93, 94];
+            TensorSpan<int> spanInt;
+            fixed (int* p = a)
+            {
+                spanInt = new TensorSpan<int>(p, 4);
+                Assert.Equal(1, spanInt.Rank);
+                Assert.Equal(4, spanInt.Lengths[0]);
+                Assert.Equal(91, spanInt[0]);
+                Assert.Equal(92, spanInt[1]);
+                Assert.Equal(-93, spanInt[2]);
+                Assert.Equal(94, spanInt[3]);
+            }
+
+            // Make sure empty span works
+            // Should be a Tensor with 0 elements but Rank 1 with dimension 0 length 0
+            Span<int> b = [];
+            fixed (int* p = b)
+            {
+                spanInt = new TensorSpan<int>(p, 0);
+                Assert.Equal(1, spanInt.Rank);
+                Assert.Equal(0, spanInt.Lengths[0]);
+                Assert.Equal(0, spanInt.FlattenedLength);
+                Assert.Equal(0, spanInt.Strides[0]);
+                // Make sure it still throws on index 0
+                Assert.Throws<IndexOutOfRangeException>(() =>
+                {
+                    Span<int> b = [];
+                    fixed (int* p = b)
+                    {
+                        var spanInt = new TensorSpan<int>(p, 0);
+                        var x = spanInt[0];
+                    }
+                });
+            }
+
+            // Make sure 2D array works
+            fixed (int* p = a)
+            {
+                spanInt = new TensorSpan<int>(p, 4, [2, 2], default);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(91, spanInt[0, 0]);
+                Assert.Equal(92, spanInt[0, 1]);
+                Assert.Equal(-93, spanInt[1, 0]);
+                Assert.Equal(94, spanInt[1, 1]);
+
+                // Make sure can use only some of the array
+                spanInt = new TensorSpan<int>(p, 4, [1, 2], default);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(1, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(91, spanInt[0, 0]);
+                Assert.Equal(92, spanInt[0, 1]);
+                Assert.Throws<IndexOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new TensorSpan<int>(p, 4, [1, 2], default);
+                        var x = spanInt[1, 1];
+                    }
+                });
+
+                Assert.Throws<IndexOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new TensorSpan<int>(p, 4, [1, 2], default);
+                        var x = spanInt[1, 0];
+                    }
+                });
+
+                // Make sure Index offset works correctly
+                spanInt = new TensorSpan<int>(p + 1, 3, [1, 2], default);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(1, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(92, spanInt[0, 0]);
+                Assert.Equal(-93, spanInt[0, 1]);
+
+                // Make sure Index offset works correctly
+                spanInt = new TensorSpan<int>(p + 2, 2, [1, 2], default);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(1, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(-93, spanInt[0, 0]);
+                Assert.Equal(94, spanInt[0, 1]);
+
+                // Make sure we catch that there aren't enough elements in the array for the lengths
+                Assert.Throws<ArgumentException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new TensorSpan<int>(p + 3, 1, [1, 2], default);
+                    }
+                });
+
+                // Make sure 2D array works with basic strides
+                spanInt = new TensorSpan<int>(p, 4, [2, 2], [2, 1]);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(91, spanInt[0, 0]);
+                Assert.Equal(92, spanInt[0, 1]);
+                Assert.Equal(-93, spanInt[1, 0]);
+                Assert.Equal(94, spanInt[1, 1]);
+
+                // Make sure 2D array works with stride of 0 to loop over first 2 elements again
+                spanInt = new TensorSpan<int>(p, 4, [2, 2], [0, 1]);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(91, spanInt[0, 0]);
+                Assert.Equal(92, spanInt[0, 1]);
+                Assert.Equal(91, spanInt[1, 0]);
+                Assert.Equal(92, spanInt[1, 1]);
+
+                // Make sure 2D array works with stride of 0 and initial offset to loop over last 2 elements again
+                spanInt = new TensorSpan<int>(p + 2, 2, [2, 2], [0, 1]);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(-93, spanInt[0, 0]);
+                Assert.Equal(94, spanInt[0, 1]);
+                Assert.Equal(-93, spanInt[1, 0]);
+                Assert.Equal(94, spanInt[1, 1]);
+
+                // Make sure 2D array works with strides of all 0 and initial offset to loop over last element again
+                spanInt = new TensorSpan<int>(p + 3, 1, [2, 2], [0, 0]);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(94, spanInt[0, 0]);
+                Assert.Equal(94, spanInt[0, 1]);
+                Assert.Equal(94, spanInt[1, 0]);
+                Assert.Equal(94, spanInt[1, 1]);
+
+                // Make sure strides can't be negative
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new TensorSpan<int>(p, 4, [1, 2], [-1, 0]);
+                    }
+                });
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new TensorSpan<int>(p, 4, [1, 2], [0, -1]);
+                    }
+                });
+
+                // Make sure lengths can't be negative
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new TensorSpan<int>(p, 4, [-1, 2], []);
+                    }
+                });
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new TensorSpan<int>(p, 4, [1, -2], []);
+                    }
+                });
+
+                // Make sure can't use negative data length amount
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new TensorSpan<int>(p, -1, [1, -2], []);
+                    }
+                });
+
+                // Make sure 2D array works with strides to hit element 0,0,2,2
+                spanInt = new TensorSpan<int>(p, 4, [2, 2], [2, 0]);
+                Assert.Equal(2, spanInt.Rank);
+                Assert.Equal(2, spanInt.Lengths[0]);
+                Assert.Equal(2, spanInt.Lengths[1]);
+                Assert.Equal(91, spanInt[0, 0]);
+                Assert.Equal(91, spanInt[0, 1]);
+                Assert.Equal(-93, spanInt[1, 0]);
+                Assert.Equal(-93, spanInt[1, 1]);
+
+                // Make sure you can't overlap elements using strides
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                {
+                    Span<int> a = [91, 92, -93, 94];
+                    fixed (int* p = a)
+                    {
+                        var spanInt = new TensorSpan<int>(p, 4, [2, 2], [1, 1]);
+                    }
+                });
+            }
         }
 
         [Fact]
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
index 822469f3c4a4c..d3a36377f32ca 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
@@ -1,18 +1,595 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Security.Cryptography.X509Certificates;
-using System.Text;
-using System.Threading.Tasks;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace System.Numerics.Tensors.Tests
 {
     public class TensorTests
     {
+        #region TensorPrimitivesForwardsTests
+        private void FillTensor<T>(Span<T> span)
+            where T : INumberBase<T>
+        {
+            for (int i = 0; i < span.Length; i++)
+            {
+                span[i] = T.CreateChecked((Random.Shared.NextSingle() * 100) - 50);
+            }
+        }
+
+        private static nint CalculateTotalLength(ReadOnlySpan<nint> lengths)
+        {
+            if (lengths.IsEmpty)
+                return 0;
+            nint totalLength = 1;
+            for (int i = 0; i < lengths.Length; i++)
+            {
+                totalLength *= lengths[i];
+            }
+
+            return totalLength;
+        }
+
+        public delegate void PerformCalculationSpanInSpanOut<T>(ReadOnlySpan<T> input, Span<T> output);
+
+        public static IEnumerable<object[]> SpanInSpanOutData()
+        {
+            yield return Create<float>(TensorPrimitives.Abs<float>, Tensor.Abs);
+            yield return Create<float>(TensorPrimitives.Abs, Tensor.AbsInPlace);
+            yield return Create<float>(TensorPrimitives.Acos, Tensor.Acos);
+            yield return Create<float>(TensorPrimitives.Acos, Tensor.AcosInPlace);
+            yield return Create<float>(TensorPrimitives.Acosh, Tensor.Acosh);
+            yield return Create<float>(TensorPrimitives.Acosh, Tensor.AcoshInPlace);
+            yield return Create<float>(TensorPrimitives.AcosPi, Tensor.AcosPi);
+            yield return Create<float>(TensorPrimitives.AcosPi, Tensor.AcosPiInPlace);
+            yield return Create<float>(TensorPrimitives.Asin, Tensor.Asin);
+            yield return Create<float>(TensorPrimitives.Asin, Tensor.AsinInPlace);
+            yield return Create<float>(TensorPrimitives.Asinh, Tensor.Asinh);
+            yield return Create<float>(TensorPrimitives.Asinh, Tensor.AsinhInPlace);
+            yield return Create<float>(TensorPrimitives.AsinPi, Tensor.AsinPi);
+            yield return Create<float>(TensorPrimitives.AsinPi, Tensor.AsinPiInPlace);
+            yield return Create<float>(TensorPrimitives.Atan, Tensor.Atan);
+            yield return Create<float>(TensorPrimitives.Atan, Tensor.AtanInPlace);
+            yield return Create<float>(TensorPrimitives.Atanh, Tensor.Atanh);
+            yield return Create<float>(TensorPrimitives.Atanh, Tensor.AtanhInPlace);
+            yield return Create<float>(TensorPrimitives.AtanPi, Tensor.AtanPi);
+            yield return Create<float>(TensorPrimitives.AtanPi, Tensor.AtanPiInPlace);
+            yield return Create<float>(TensorPrimitives.Cbrt, Tensor.CubeRoot);
+            yield return Create<float>(TensorPrimitives.Cbrt, Tensor.CubeRootInPlace);
+            yield return Create<float>(TensorPrimitives.Ceiling, Tensor.Ceiling);
+            yield return Create<float>(TensorPrimitives.Ceiling, Tensor.CeilingInPlace);
+            yield return Create<float>(TensorPrimitives.Cos, Tensor.Cos);
+            yield return Create<float>(TensorPrimitives.Cos, Tensor.CosInPlace);
+            yield return Create<float>(TensorPrimitives.Cosh, Tensor.Cosh);
+            yield return Create<float>(TensorPrimitives.Cosh, Tensor.CoshInPlace);
+            yield return Create<float>(TensorPrimitives.CosPi, Tensor.CosPi);
+            yield return Create<float>(TensorPrimitives.CosPi, Tensor.CosPiInPlace);
+            yield return Create<float>(TensorPrimitives.DegreesToRadians, Tensor.DegreesToRadians);
+            yield return Create<float>(TensorPrimitives.DegreesToRadians, Tensor.DegreesToRadiansInPlace);
+            yield return Create<float>(TensorPrimitives.Exp, Tensor.Exp);
+            yield return Create<float>(TensorPrimitives.Exp, Tensor.ExpInPlace);
+            yield return Create<float>(TensorPrimitives.Exp10, Tensor.Exp10);
+            yield return Create<float>(TensorPrimitives.Exp10, Tensor.Exp10InPlace);
+            yield return Create<float>(TensorPrimitives.Exp10M1, Tensor.Exp10M1);
+            yield return Create<float>(TensorPrimitives.Exp10M1, Tensor.Exp10M1InPlace);
+            yield return Create<float>(TensorPrimitives.Exp2, Tensor.Exp2);
+            yield return Create<float>(TensorPrimitives.Exp2, Tensor.Exp2InPlace);
+            yield return Create<float>(TensorPrimitives.Exp2M1, Tensor.Exp2M1);
+            yield return Create<float>(TensorPrimitives.Exp2M1, Tensor.Exp2M1InPlace);
+            yield return Create<float>(TensorPrimitives.ExpM1, Tensor.ExpM1);
+            yield return Create<float>(TensorPrimitives.ExpM1, Tensor.ExpM1InPlace);
+            yield return Create<float>(TensorPrimitives.Floor, Tensor.Floor);
+            yield return Create<float>(TensorPrimitives.Floor, Tensor.FloorInPlace);
+            yield return Create<int>(TensorPrimitives.LeadingZeroCount, Tensor.LeadingZeroCount);
+            yield return Create<int>(TensorPrimitives.LeadingZeroCount, Tensor.LeadingZeroCount);
+            yield return Create<float>(TensorPrimitives.Log, Tensor.Log);
+            yield return Create<float>(TensorPrimitives.Log, Tensor.LogInPlace);
+            yield return Create<float>(TensorPrimitives.Log10, Tensor.Log10);
+            yield return Create<float>(TensorPrimitives.Log10, Tensor.Log10InPlace);
+            yield return Create<float>(TensorPrimitives.Log10P1, Tensor.Log10P1);
+            yield return Create<float>(TensorPrimitives.Log10P1, Tensor.Log10P1InPlace);
+            yield return Create<float>(TensorPrimitives.Log2, Tensor.Log2);
+            yield return Create<float>(TensorPrimitives.Log2, Tensor.Log2InPlace);
+            yield return Create<float>(TensorPrimitives.Log2P1, Tensor.Log2P1);
+            yield return Create<float>(TensorPrimitives.Log2P1, Tensor.Log2P1InPlace);
+            yield return Create<float>(TensorPrimitives.LogP1, Tensor.LogP1);
+            yield return Create<float>(TensorPrimitives.LogP1, Tensor.LogP1InPlace);
+            yield return Create<float>(TensorPrimitives.Negate, Tensor.Negate);
+            yield return Create<float>(TensorPrimitives.Negate, Tensor.NegateInPlace);
+            yield return Create<float>(TensorPrimitives.OnesComplement, Tensor.OnesComplement);
+            yield return Create<float>(TensorPrimitives.OnesComplement, Tensor.OnesComplementInPlace);
+            yield return Create<int>(TensorPrimitives.PopCount, Tensor.PopCount);
+            yield return Create<int>(TensorPrimitives.PopCount, Tensor.PopCountInPlace);
+            yield return Create<float>(TensorPrimitives.RadiansToDegrees, Tensor.RadiansToDegrees);
+            yield return Create<float>(TensorPrimitives.RadiansToDegrees, Tensor.RadiansToDegreesInPlace);
+            yield return Create<float>(TensorPrimitives.Reciprocal, Tensor.Reciprocal);
+            yield return Create<float>(TensorPrimitives.Reciprocal, Tensor.ReciprocalInPlace);
+            yield return Create<float>(TensorPrimitives.Round, Tensor.Round);
+            yield return Create<float>(TensorPrimitives.Round, Tensor.RoundInPlace);
+            yield return Create<float>(TensorPrimitives.Sigmoid, Tensor.Sigmoid);
+            yield return Create<float>(TensorPrimitives.Sigmoid, Tensor.SigmoidInPlace);
+            yield return Create<float>(TensorPrimitives.Sin, Tensor.Sin);
+            yield return Create<float>(TensorPrimitives.Sin, Tensor.SinInPlace);
+            yield return Create<float>(TensorPrimitives.Sinh, Tensor.Sinh);
+            yield return Create<float>(TensorPrimitives.Sinh, Tensor.SinhInPlace);
+            yield return Create<float>(TensorPrimitives.SinPi, Tensor.SinPi);
+            yield return Create<float>(TensorPrimitives.SinPi, Tensor.SinPiInPlace);
+            yield return Create<float>(TensorPrimitives.SoftMax, Tensor.SoftMax);
+            yield return Create<float>(TensorPrimitives.SoftMax, Tensor.SoftMaxInPlace);
+            yield return Create<float>(TensorPrimitives.Sqrt, Tensor.Sqrt);
+            yield return Create<float>(TensorPrimitives.Sqrt, Tensor.SqrtInPlace);
+            yield return Create<float>(TensorPrimitives.Tan, Tensor.Tan);
+            yield return Create<float>(TensorPrimitives.Tan, Tensor.TanInPlace);
+            yield return Create<float>(TensorPrimitives.Tanh, Tensor.Tanh);
+            yield return Create<float>(TensorPrimitives.Tanh, Tensor.TanhInPlace);
+            yield return Create<float>(TensorPrimitives.TanPi, Tensor.TanPi);
+            yield return Create<float>(TensorPrimitives.TanPi, Tensor.TanPiInPlace);
+            yield return Create<float>(TensorPrimitives.Truncate, Tensor.Truncate);
+            yield return Create<float>(TensorPrimitives.Truncate, Tensor.TruncateInPlace);
+
+            static object[] Create<T>(PerformCalculationSpanInSpanOut<T> tensorPrimitivesMethod, Func<Tensor<T>, Tensor<T>> tensorOperation)
+                => new object[] { tensorPrimitivesMethod, tensorOperation };
+        }
+
+        [Theory, MemberData(nameof(SpanInSpanOutData))]
+        public void TensorExtensionsSpanInSpanOut<T>(PerformCalculationSpanInSpanOut<T> tensorPrimitivesOperation, Func<Tensor<T>, Tensor<T>> tensorOperation)
+            where T: INumberBase<T>
+        {
+            Assert.All(Helpers.TensorShapes, tensorLength =>
+            {
+                nint length = CalculateTotalLength(tensorLength);
+                T[] data = new T[length];
+                T[] expectedOutput = new T[length];
+
+                FillTensor<T>(data);
+                Tensor<T> x = Tensor.Create<T>(data, tensorLength, []);
+                tensorPrimitivesOperation((ReadOnlySpan<T>)data, expectedOutput);
+                Tensor<T> results = tensorOperation(x);
+
+                Assert.Equal(tensorLength, results.Lengths);
+                nint[] startingIndex = new nint[tensorLength.Length];
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref results[startingIndex], (int)length);
+
+                for (int i = 0; i < data.Length; i++)
+                {
+                    Assert.Equal(expectedOutput[i], span[i]);
+                }
+            });
+        }
+
+        public delegate T PerformCalculationSpanInTOut<T>(ReadOnlySpan<T> input);
+        public static IEnumerable<object[]> SpanInFloatOutData()
+        {
+            yield return Create<float>(TensorPrimitives.Max, Tensor.Max);
+            yield return Create<float>(TensorPrimitives.MaxMagnitude, Tensor.MaxMagnitude);
+            yield return Create<float>(TensorPrimitives.MaxNumber, Tensor.MaxNumber);
+            yield return Create<float>(TensorPrimitives.Min, Tensor.Min);
+            yield return Create<float>(TensorPrimitives.MinMagnitude, Tensor.MinMagnitude);
+            yield return Create<float>(TensorPrimitives.MinNumber, Tensor.MinNumber);
+            yield return Create<float>(TensorPrimitives.Norm, Tensor.Norm);
+            yield return Create<float>(TensorPrimitives.Product, Tensor.Product);
+            yield return Create<float>(TensorPrimitives.Sum, Tensor.Sum);
+
+            static object[] Create<T>(PerformCalculationSpanInTOut<T> tensorPrimitivesMethod, Func<Tensor<T>, T> tensorOperation)
+                => new object[] { tensorPrimitivesMethod, tensorOperation };
+        }
+
+        [Theory, MemberData(nameof(SpanInFloatOutData))]
+        public void TensorExtensionsSpanInTOut<T>(PerformCalculationSpanInTOut<T> tensorPrimitivesOperation, Func<Tensor<T>, T> tensorOperation)
+            where T : INumberBase<T>
+        {
+            Assert.All(Helpers.TensorShapes, tensorLength =>
+            {
+                nint length = CalculateTotalLength(tensorLength);
+                T[] data = new T[length];
+
+                FillTensor<T>(data);
+                Tensor<T> x = Tensor.Create<T>(data, tensorLength, []);
+                T expectedOutput = tensorPrimitivesOperation((ReadOnlySpan<T>)data);
+                T results = tensorOperation(x);
+
+                Assert.Equal(expectedOutput, results);
+            });
+        }
+
+        public delegate void PerformCalculationTwoSpanInSpanOut<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo, Span<T> output);
+        public static IEnumerable<object[]> TwoSpanInSpanOutData()
+        {
+            yield return Create<float>(TensorPrimitives.Add, Tensor.Add);
+            yield return Create<float>(TensorPrimitives.Add, Tensor.AddInPlace);
+            yield return Create<float>(TensorPrimitives.Atan2, Tensor.Atan2);
+            yield return Create<float>(TensorPrimitives.Atan2, Tensor.Atan2InPlace);
+            yield return Create<float>(TensorPrimitives.Atan2Pi, Tensor.Atan2Pi);
+            yield return Create<float>(TensorPrimitives.Atan2Pi, Tensor.Atan2PiInPlace);
+            yield return Create<float>(TensorPrimitives.CopySign, Tensor.CopySign);
+            yield return Create<float>(TensorPrimitives.CopySign, Tensor.CopySignInPlace);
+            yield return Create<float>(TensorPrimitives.Divide, Tensor.Divide);
+            yield return Create<float>(TensorPrimitives.Divide, Tensor.DivideInPlace);
+            yield return Create<float>(TensorPrimitives.Hypot, Tensor.Hypotenuse);
+            yield return Create<float>(TensorPrimitives.Hypot, Tensor.HypotenuseInPlace);
+            yield return Create<float>(TensorPrimitives.Ieee754Remainder, Tensor.Ieee754Remainder);
+            yield return Create<float>(TensorPrimitives.Ieee754Remainder, Tensor.Ieee754RemainderInPlace);
+            yield return Create<float>(TensorPrimitives.Multiply, Tensor.Multiply);
+            yield return Create<float>(TensorPrimitives.Multiply, Tensor.MultiplyInPlace);
+            yield return Create<float>(TensorPrimitives.Pow, Tensor.Pow);
+            yield return Create<float>(TensorPrimitives.Pow, Tensor.PowInPlace);
+            yield return Create<float>(TensorPrimitives.Subtract, Tensor.Subtract);
+            yield return Create<float>(TensorPrimitives.Subtract, Tensor.SubtractInPlace);
+
+            static object[] Create<T>(PerformCalculationTwoSpanInSpanOut<T> tensorPrimitivesMethod, Func<Tensor<T>, Tensor<T>, Tensor<T>> tensorOperation)
+                => new object[] { tensorPrimitivesMethod, tensorOperation };
+        }
+
+        [Theory, MemberData(nameof(TwoSpanInSpanOutData))]
+        public void TensorExtensionsTwoSpanInSpanOut<T>(PerformCalculationTwoSpanInSpanOut<T> tensorPrimitivesOperation, Func<Tensor<T>, Tensor<T>, Tensor<T>> tensorOperation)
+            where T: INumberBase<T>
+        {
+            Assert.All(Helpers.TensorShapes, tensorLength =>
+            {
+                nint length = CalculateTotalLength(tensorLength);
+                T[] data1 = new T[length];
+                T[] data2 = new T[length];
+                T[] expectedOutput = new T[length];
+
+                FillTensor<T>(data1);
+                FillTensor<T>(data2);
+                Tensor<T> x = Tensor.Create<T>(data1, tensorLength, []);
+                Tensor<T> y = Tensor.Create<T>(data2, tensorLength, []);
+                tensorPrimitivesOperation((ReadOnlySpan<T>)data1, data2, expectedOutput);
+                Tensor<T> results = tensorOperation(x, y);
+
+                Assert.Equal(tensorLength, results.Lengths);
+                nint[] startingIndex = new nint[tensorLength.Length];
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref results[startingIndex], (int)length);
+
+                for (int i = 0; i < data1.Length; i++)
+                {
+                    Assert.Equal(expectedOutput[i], span[i]);
+                }
+            });
+        }
+
+        public delegate T PerformCalculationTwoSpanInFloatOut<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo);
+        public static IEnumerable<object[]> TwoSpanInFloatOutData()
+        {
+            yield return Create<float>(TensorPrimitives.Distance, Tensor.Distance);
+            yield return Create<float>(TensorPrimitives.Dot, Tensor.Dot);
+
+            static object[] Create<T>(PerformCalculationTwoSpanInFloatOut<T> tensorPrimitivesMethod, Func<Tensor<T>, Tensor<T>, T> tensorOperation)
+                => new object[] { tensorPrimitivesMethod, tensorOperation };
+        }
+
+        [Theory, MemberData(nameof(TwoSpanInFloatOutData))]
+        public void TensorExtensionsTwoSpanInFloatOut<T>(PerformCalculationTwoSpanInFloatOut<T> tensorPrimitivesOperation, Func<Tensor<T>, Tensor<T>, T> tensorOperation)
+            where T: INumberBase<T>
+        {
+            Assert.All(Helpers.TensorShapes, tensorLength =>
+            {
+                nint length = CalculateTotalLength(tensorLength);
+                T[] data1 = new T[length];
+                T[] data2 = new T[length];
+
+                FillTensor<T>(data1);
+                FillTensor<T>(data2);
+                Tensor<T> x = Tensor.Create<T>(data1, tensorLength, []);
+                Tensor<T> y = Tensor.Create<T>(data2, tensorLength, []);
+                T expectedOutput = tensorPrimitivesOperation((ReadOnlySpan<T>)data1, data2);
+                T results = tensorOperation(x, y);
+
+                Assert.Equal(expectedOutput, results);
+            });
+        }
+
+        #endregion
+
+        [Fact]
+        public static void TensorFactoryCreateUninitializedTests()
+        {
+            // Basic tensor creation
+            Tensor<int> t1 = Tensor.CreateUninitialized<int>([1]);
+            Assert.Equal(1, t1.Rank);
+            Assert.Equal(1, t1.Lengths.Length);
+            Assert.Equal(1, t1.Lengths[0]);
+            Assert.Equal(1, t1.Strides.Length);
+            Assert.Equal(1, t1.Strides[0]);
+            Assert.False(t1.IsPinned);
+
+            // Make sure can't index too many dimensions
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var x = t1[1, 1];
+            });
+
+            // Make sure can't index beyond end
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var x = t1[1];
+            });
+
+            // Make sure can't index negative index
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var x = t1[-1];
+            });
+
+            // Make sure lengths can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                Tensor<int> t1 = Tensor.CreateUninitialized<int>([-1]);
+            });
+
+            t1 = Tensor.CreateUninitialized<int>([0]);
+            Assert.Equal(1, t1.Rank);
+            Assert.Equal(1, t1.Lengths.Length);
+            Assert.Equal(0, t1.Lengths[0]);
+            Assert.Equal(1, t1.Strides.Length);
+            Assert.Equal(0, t1.Strides[0]);
+            Assert.False(t1.IsPinned);
+
+            t1 = Tensor.CreateUninitialized<int>([]);
+            Assert.Equal(1, t1.Rank);
+            Assert.Equal(1, t1.Lengths.Length);
+            Assert.Equal(0, t1.Lengths[0]);
+            Assert.Equal(1, t1.Strides.Length);
+            Assert.Equal(0, t1.Strides[0]);
+            Assert.False(t1.IsPinned);
+
+            // Null should behave like empty array since there is no "null" span.
+            t1 = Tensor.CreateUninitialized<int>(null);
+            Assert.Equal(1, t1.Rank);
+            Assert.Equal(1, t1.Lengths.Length);
+            Assert.Equal(0, t1.Lengths[0]);
+            Assert.Equal(1, t1.Strides.Length);
+            Assert.Equal(0, t1.Strides[0]);
+            Assert.False(t1.IsPinned);
+
+            // Make sure pinned works
+            t1 = Tensor.CreateUninitialized<int>([1], true);
+            Assert.Equal(1, t1.Rank);
+            Assert.Equal(1, t1.Lengths.Length);
+            Assert.Equal(1, t1.Lengths[0]);
+            Assert.Equal(1, t1.Strides.Length);
+            Assert.Equal(1, t1.Strides[0]);
+            Assert.True(t1.IsPinned);
+
+            // Make sure 2D array works with basic strides
+            t1 = Tensor.CreateUninitialized<int>([2, 2], [2, 1]);
+            Assert.Equal(2, t1.Rank);
+            Assert.Equal(2, t1.Lengths[0]);
+            Assert.Equal(2, t1.Lengths[1]);
+            // Can't validate actual values since it's uninitialized
+            // So by checking the type we assert no errors were thrown
+            Assert.IsType<int>(t1[0, 0]);
+            Assert.IsType<int>(t1[0, 1]);
+            Assert.IsType<int>(t1[1, 0]);
+            Assert.IsType<int>(t1[1, 1]);
+
+            // Make sure 2D array works with stride of 0 to loop over first 2 elements again
+            t1 = Tensor.CreateUninitialized<int>([2, 2], [0, 1]);
+            Assert.Equal(2, t1.Rank);
+            Assert.Equal(2, t1.Lengths[0]);
+            Assert.Equal(2, t1.Lengths[1]);
+            // Can't validate actual values since it's uninitialized
+            // But since it loops over the first 2 elements we can assert the results are the same for those.
+            Assert.Equal(t1[0, 0], t1[1, 0]);
+            Assert.Equal(t1[0, 1], t1[1, 1]);
+
+            // Make sure 2D array works with strides of all 0 to loop over first element again
+            t1 = Tensor.CreateUninitialized<int>([2, 2], [0, 0]);
+            Assert.Equal(2, t1.Rank);
+            Assert.Equal(2, t1.Lengths[0]);
+            Assert.Equal(2, t1.Lengths[1]);
+            // Can't validate actual values since it's uninitialized
+            // But since it loops over the first element we can assert the results are the same.
+            Assert.Equal(t1[0, 0], t1[0, 1]);
+            Assert.Equal(t1[0, 0], t1[1, 0]);
+            Assert.Equal(t1[0, 0], t1[1, 1]);
+
+            // Make sure strides can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var t1 = Tensor.CreateUninitialized<int>([1, 2], [-1, 0], false);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var t1 = Tensor.CreateUninitialized<int>([1, 2], [0, -1], false);
+            });
+
+            // Make sure lengths can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var t1 = Tensor.CreateUninitialized<int>([-1, 2], [], false);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var t1 = Tensor.CreateUninitialized<int>([1, -2], [], false);
+            });
+
+            // Make sure 2D array works with strides to hit element 0,0,2,2
+            t1 = Tensor.CreateUninitialized<int>([2, 2], [2, 0]);
+            Assert.Equal(2, t1.Rank);
+            Assert.Equal(2, t1.Lengths[0]);
+            Assert.Equal(2, t1.Lengths[1]);
+            Assert.Equal(t1[0, 0], t1[0, 1]);
+            Assert.Equal(t1[1, 0], t1[1, 1]);
+
+            // Make sure you can't overlap elements using strides
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var t1 = Tensor.CreateUninitialized<int>([2, 2], [1, 1], false);
+            });
+        }
+
+        [Fact]
+        public static void TensorFactoryCreateTests()
+        {
+            // Basic tensor creation
+            Tensor<int> t1 = Tensor.Create<int>([1]);
+            Assert.Equal(1, t1.Rank);
+            Assert.Equal(1, t1.Lengths.Length);
+            Assert.Equal(1, t1.Lengths[0]);
+            Assert.Equal(1, t1.Strides.Length);
+            Assert.Equal(1, t1.Strides[0]);
+            Assert.False(t1.IsPinned);
+            Assert.Equal(0, t1[0]);
+
+            // Make sure can't index too many dimensions
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var x = t1[1, 1];
+            });
+
+            // Make sure can't index beyond end
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var x = t1[1];
+            });
+
+            // Make sure can't index negative index
+            Assert.Throws<IndexOutOfRangeException>(() =>
+            {
+                var x = t1[-1];
+            });
+
+            // Make sure lengths can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                Tensor<int> t1 = Tensor.Create<int>([-1]);
+            });
+
+            t1 = Tensor.Create<int>([0]);
+            Assert.Equal(1, t1.Rank);
+            Assert.Equal(1, t1.Lengths.Length);
+            Assert.Equal(0, t1.Lengths[0]);
+            Assert.Equal(1, t1.Strides.Length);
+            Assert.Equal(0, t1.Strides[0]);
+            Assert.False(t1.IsPinned);
+
+            t1 = Tensor.Create<int>([]);
+            Assert.Equal(1, t1.Rank);
+            Assert.Equal(1, t1.Lengths.Length);
+            Assert.Equal(0, t1.Lengths[0]);
+            Assert.Equal(1, t1.Strides.Length);
+            Assert.Equal(0, t1.Strides[0]);
+            Assert.False(t1.IsPinned);
+
+            // Null should behave like empty array since there is no "null" span.
+            t1 = Tensor.Create<int>(null);
+            Assert.Equal(1, t1.Rank);
+            Assert.Equal(1, t1.Lengths.Length);
+            Assert.Equal(0, t1.Lengths[0]);
+            Assert.Equal(1, t1.Strides.Length);
+            Assert.Equal(0, t1.Strides[0]);
+            Assert.False(t1.IsPinned);
+
+            // Make sure pinned works
+            t1 = Tensor.Create<int>([1], true);
+            Assert.Equal(1, t1.Rank);
+            Assert.Equal(1, t1.Lengths.Length);
+            Assert.Equal(1, t1.Lengths[0]);
+            Assert.Equal(1, t1.Strides.Length);
+            Assert.Equal(1, t1.Strides[0]);
+            Assert.True(t1.IsPinned);
+            Assert.Equal(0, t1[0]);
+
+            int[] a = [91, 92, -93, 94];
+            // Make sure 2D array works with basic strides
+            t1 = Tensor.Create<int>(a, [2, 2], [2, 1]);
+            Assert.Equal(2, t1.Rank);
+            Assert.Equal(2, t1.Lengths[0]);
+            Assert.Equal(2, t1.Lengths[1]);
+            Assert.Equal(91, t1[0, 0]);
+            Assert.Equal(92, t1[0, 1]);
+            Assert.Equal(-93, t1[1, 0]);
+            Assert.Equal(94, t1[1, 1]);
+
+            // Make sure 2D array works with stride of 0 to loop over first 2 elements again
+            t1 = Tensor.Create<int>(a, [2, 2], [0, 1]);
+            Assert.Equal(2, t1.Rank);
+            Assert.Equal(2, t1.Lengths[0]);
+            Assert.Equal(2, t1.Lengths[1]);
+            Assert.Equal(91, t1[0, 0]);
+            Assert.Equal(92, t1[0, 1]);
+            Assert.Equal(91, t1[1, 0]);
+            Assert.Equal(92, t1[1, 1]);
+
+            // Make sure 2D array works with strides of all 0 to loop over first element again
+            t1 = Tensor.Create<int>(a, [2, 2], [0, 0]);
+            Assert.Equal(2, t1.Rank);
+            Assert.Equal(2, t1.Lengths[0]);
+            Assert.Equal(2, t1.Lengths[1]);
+            Assert.Equal(91, t1[0, 0]);
+            Assert.Equal(91, t1[0, 1]);
+            Assert.Equal(91, t1[1, 0]);
+            Assert.Equal(91, t1[1, 1]);
+
+            // Make sure 2D array works with strides of all 0 only 1 element to make sure it doesn't leave that element
+            t1 = Tensor.Create<int>([a[3]], [2, 2], [0, 0]);
+            Assert.Equal(2, t1.Rank);
+            Assert.Equal(2, t1.Lengths[0]);
+            Assert.Equal(2, t1.Lengths[1]);
+            Assert.Equal(94, t1[0, 0]);
+            Assert.Equal(94, t1[0, 1]);
+            Assert.Equal(94, t1[1, 0]);
+            Assert.Equal(94, t1[1, 1]);
+
+            // Make sure strides can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var t1 = Tensor.Create<int>([1, 2], [-1, 0], false);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var t1 = Tensor.Create<int>([1, 2], [0, -1], false);
+            });
+
+            // Make sure lengths can't be negative
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var t1 = Tensor.Create<int>([-1, 2], [], false);
+            });
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var t1 = Tensor.Create<int>([1, -2], [], false);
+            });
+
+            // Make sure 2D array works with strides to hit element 0,0,2,2
+            t1 = Tensor.Create<int>(a, [2, 2], [2, 0]);
+            Assert.Equal(2, t1.Rank);
+            Assert.Equal(2, t1.Lengths[0]);
+            Assert.Equal(2, t1.Lengths[1]);
+            Assert.Equal(91, t1[0, 0]);
+            Assert.Equal(91, t1[0, 1]);
+            Assert.Equal(-93, t1[1, 0]);
+            Assert.Equal(-93, t1[1, 1]);
+
+            // Make sure you can't overlap elements using strides
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                Span<int> a = [91, 92, -93, 94];
+                var t1 = Tensor.Create<int>([2, 2], [1, 1], false);
+            });
+        }
+        
+        [Fact]
+        public static void TensorCosineSimilarityTests()
+        {
+            float[] a = [0, 0, 0, 1, 1, 1];
+            float[] b = [1, 0, 0, 1, 1, 0];
+
+            Tensor<float> left = Tensor.Create<float>(a, [2,3]);
+            Tensor<float> right = Tensor.Create<float>(b, [2,3]);
+
+            Tensor<float> result = Tensor.CosineSimilarity(left, right);
+            Assert.Equal(2, result.Rank);
+            Assert.Equal(2, result.Lengths[0]);
+            Assert.Equal(2, result.Lengths[1]);
+
+
+            Assert.Equal(float.NaN, result[0, 0]);
+            Assert.Equal(float.NaN, result[0, 1]);
+
+            Assert.Equal(0.57735, result[1, 0], .00001);
+            Assert.Equal(0.81649, result[1, 1], .00001);
+        }
+
         [Fact]
         public static void TensorSequenceEqualTests()
         {
@@ -823,10 +1400,10 @@ public static void TensorPermuteTests()
         public static void IntArrayAsTensor()
         {
             int[] a = [91, 92, -93, 94];
-            TensorSpan<int> spanInt = a.AsTensorSpan(4);
+            TensorSpan<int> t1 = a.AsTensorSpan(4);
             nint[] dims = [4];
             var tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
-            spanInt.CopyTo(tensor);
+            t1.CopyTo(tensor);
             Assert.Equal(1, tensor.Rank);
 
             Assert.Equal(1, tensor.Lengths.Length);
@@ -852,13 +1429,13 @@ public static void IntArrayAsTensor()
             a[1] = 92;
             a[2] = -93;
             a[3] = 94;
-            spanInt = a.AsTensorSpan(2, 2);
+            t1 = a.AsTensorSpan(2, 2);
             dims = [2, 2];
             tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
-            spanInt.CopyTo(tensor);
+            t1.CopyTo(tensor);
             Assert.Equal(a, tensor.ToArray());
             Assert.Equal(2, tensor.Rank);
-            //Assert.Equal(4, spanInt.FlattenedLength);
+            //Assert.Equal(4, t1.FlattenedLength);
             Assert.Equal(2, tensor.Lengths.Length);
             Assert.Equal(2, tensor.Lengths[0]);
             Assert.Equal(2, tensor.Lengths[1]);
@@ -957,9 +1534,9 @@ public static void TensorFillTest()
         public static void TensorClearTest()
         {
             int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-            TensorSpan<int> spanInt = a.AsTensorSpan(3, 3);
+            TensorSpan<int> t1 = a.AsTensorSpan(3, 3);
             var tensor = Tensor.CreateUninitialized<int>([3, 3], false);
-            spanInt.CopyTo(tensor);
+            t1.CopyTo(tensor);
             var slice = tensor.Slice(0..2, 0..2);
             slice.Clear();
             Assert.Equal(0, slice[0, 0]);
@@ -987,9 +1564,9 @@ public static void TensorClearTest()
             }
 
             a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-            spanInt = a.AsTensorSpan(9);
+            t1 = a.AsTensorSpan(9);
             tensor = Tensor.CreateUninitialized<int>([9], false);
-            spanInt.CopyTo(tensor);
+            t1.CopyTo(tensor);
             slice = tensor.Slice(0..1);
             slice.Clear();
             Assert.Equal(0, slice[0]);
@@ -1014,9 +1591,9 @@ public static void TensorClearTest()
             }
 
             a = [.. Enumerable.Range(0, 27)];
-            spanInt = a.AsTensorSpan(3, 3, 3);
+            t1 = a.AsTensorSpan(3, 3, 3);
             tensor = Tensor.CreateUninitialized<int>([3, 3, 3], false);
-            spanInt.CopyTo(tensor);
+            t1.CopyTo(tensor);
             tensor.Clear();
             enumerator = tensor.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1025,9 +1602,9 @@ public static void TensorClearTest()
             }
 
             a = [.. Enumerable.Range(0, 12)];
-            spanInt = a.AsTensorSpan(3, 2, 2);
+            t1 = a.AsTensorSpan(3, 2, 2);
             tensor = Tensor.CreateUninitialized<int>([3, 2, 2], false);
-            spanInt.CopyTo(tensor);
+            t1.CopyTo(tensor);
             tensor.Clear();
             enumerator = tensor.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1036,9 +1613,9 @@ public static void TensorClearTest()
             }
 
             a = [.. Enumerable.Range(0, 16)];
-            spanInt = a.AsTensorSpan(2, 2, 2, 2);
+            t1 = a.AsTensorSpan(2, 2, 2, 2);
             tensor = Tensor.CreateUninitialized<int>([2, 2, 2, 2], false);
-            spanInt.CopyTo(tensor);
+            t1.CopyTo(tensor);
             tensor.Clear();
             enumerator = tensor.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1047,9 +1624,9 @@ public static void TensorClearTest()
             }
 
             a = [.. Enumerable.Range(0, 24)];
-            spanInt = a.AsTensorSpan(3, 2, 2, 2);
+            t1 = a.AsTensorSpan(3, 2, 2, 2);
             tensor = Tensor.CreateUninitialized<int>([3, 2, 2, 2], false);
-            spanInt.CopyTo(tensor);
+            t1.CopyTo(tensor);
             tensor.Clear();
             enumerator = tensor.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1059,8 +1636,8 @@ public static void TensorClearTest()
 
             // Make sure clearing a slice of a SPan doesn't clear the whole thing.
             a = [.. Enumerable.Range(0, 9)];
-            spanInt = a.AsTensorSpan(3, 3);
-            var spanSlice = spanInt.Slice(0..1, 0..3);
+            t1 = a.AsTensorSpan(3, 3);
+            var spanSlice = t1.Slice(0..1, 0..3);
             spanSlice.Clear();
             var spanEnumerator = spanSlice.GetEnumerator();
             while (spanEnumerator.MoveNext())
@@ -1068,20 +1645,20 @@ public static void TensorClearTest()
                 Assert.Equal(0, spanEnumerator.Current);
             }
 
-            Assert.Equal(0, spanInt[0, 0]);
-            Assert.Equal(0, spanInt[0, 1]);
-            Assert.Equal(0, spanInt[0, 2]);
-            Assert.Equal(3, spanInt[1, 0]);
-            Assert.Equal(4, spanInt[1, 1]);
-            Assert.Equal(5, spanInt[1, 2]);
-            Assert.Equal(6, spanInt[2, 0]);
-            Assert.Equal(7, spanInt[2, 1]);
-            Assert.Equal(8, spanInt[2, 2]);
+            Assert.Equal(0, t1[0, 0]);
+            Assert.Equal(0, t1[0, 1]);
+            Assert.Equal(0, t1[0, 2]);
+            Assert.Equal(3, t1[1, 0]);
+            Assert.Equal(4, t1[1, 1]);
+            Assert.Equal(5, t1[1, 2]);
+            Assert.Equal(6, t1[2, 0]);
+            Assert.Equal(7, t1[2, 1]);
+            Assert.Equal(8, t1[2, 2]);
 
             // Make sure clearing a slice from the middle of a SPan doesn't clear the whole thing.
             a = [.. Enumerable.Range(0, 9)];
-            spanInt = a.AsTensorSpan(3, 3);
-            spanSlice = spanInt.Slice(1..2, 0..3);
+            t1 = a.AsTensorSpan(3, 3);
+            spanSlice = t1.Slice(1..2, 0..3);
             spanSlice.Clear();
             spanEnumerator = spanSlice.GetEnumerator();
             while (spanEnumerator.MoveNext())
@@ -1089,20 +1666,20 @@ public static void TensorClearTest()
                 Assert.Equal(0, spanEnumerator.Current);
             }
 
-            Assert.Equal(0, spanInt[0, 0]);
-            Assert.Equal(1, spanInt[0, 1]);
-            Assert.Equal(2, spanInt[0, 2]);
-            Assert.Equal(0, spanInt[1, 0]);
-            Assert.Equal(0, spanInt[1, 1]);
-            Assert.Equal(0, spanInt[1, 2]);
-            Assert.Equal(6, spanInt[2, 0]);
-            Assert.Equal(7, spanInt[2, 1]);
-            Assert.Equal(8, spanInt[2, 2]);
+            Assert.Equal(0, t1[0, 0]);
+            Assert.Equal(1, t1[0, 1]);
+            Assert.Equal(2, t1[0, 2]);
+            Assert.Equal(0, t1[1, 0]);
+            Assert.Equal(0, t1[1, 1]);
+            Assert.Equal(0, t1[1, 2]);
+            Assert.Equal(6, t1[2, 0]);
+            Assert.Equal(7, t1[2, 1]);
+            Assert.Equal(8, t1[2, 2]);
 
             // Make sure clearing a slice from the end of a SPan doesn't clear the whole thing.
             a = [.. Enumerable.Range(0, 9)];
-            spanInt = a.AsTensorSpan(3, 3);
-            spanSlice = spanInt.Slice(2..3, 0..3);
+            t1 = a.AsTensorSpan(3, 3);
+            spanSlice = t1.Slice(2..3, 0..3);
             spanSlice.Clear();
             spanEnumerator = spanSlice.GetEnumerator();
             while (spanEnumerator.MoveNext())
@@ -1110,15 +1687,15 @@ public static void TensorClearTest()
                 Assert.Equal(0, spanEnumerator.Current);
             }
 
-            Assert.Equal(0, spanInt[0, 0]);
-            Assert.Equal(1, spanInt[0, 1]);
-            Assert.Equal(2, spanInt[0, 2]);
-            Assert.Equal(3, spanInt[1, 0]);
-            Assert.Equal(4, spanInt[1, 1]);
-            Assert.Equal(5, spanInt[1, 2]);
-            Assert.Equal(0, spanInt[2, 0]);
-            Assert.Equal(0, spanInt[2, 1]);
-            Assert.Equal(0, spanInt[2, 2]);
+            Assert.Equal(0, t1[0, 0]);
+            Assert.Equal(1, t1[0, 1]);
+            Assert.Equal(2, t1[0, 2]);
+            Assert.Equal(3, t1[1, 0]);
+            Assert.Equal(4, t1[1, 1]);
+            Assert.Equal(5, t1[1, 2]);
+            Assert.Equal(0, t1[2, 0]);
+            Assert.Equal(0, t1[2, 1]);
+            Assert.Equal(0, t1[2, 2]);
 
             // Make sure it works with reference types.
             object[] o = [new object(), new object(), new object(), new object(), new object(), new object(), new object(), new object(), new object()];