From a4175dff23621eeab6f20efdca5833171fdb90f4 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Thu, 24 Apr 2025 08:52:36 -0700
Subject: [PATCH 1/5] [release/10.0-preview4] Tar: Adjust the way we write GNU
 longlink and longpath metadata (#114942)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Fix 3 GNU longlink and longpath bugs

The Tar entry types Longlink and Longpath, which are exclusive to the GNU format, are metadata entries used to store longer-than-expected link or name strings (respectively). They precede their actual entry, and they are not visible to the user, only the data they hold is visible.

Most of the regular header metadata in this metadata entries is not relevant, but we need to make sure it is well formed so other tools can read them properly.

There are 3 fields that were not getting their values stored as expected by other tools:

- The mtime, ctime and atime fields need to be set to the Unix Epoch so it shows up as zeros (0x30) by default. We were storing them as null (0x0) characters instead. For consistency, if a regular entry happens to get its mtime set to the Epoch, it should also be shown as zeros (0x30).
- The uid, gid, uname and gname fields were not being set. These fields aren't really important in a metadata entry, but other tools set this to the default value (uid=gid=0 and uname=gname=root). Based on the fact that 'a value' is preferred for these fields, we can set them to the same value that the real entry has (not root).
- The long text value (either link or name) should be null terminated, and this extra character should be counted in the size of the longpath. The library libdpkg, used by the dpkg-deb tool in Debian, expects a null terminator in longlink and longpath data starting in Debian 12. Without the terminator, these entries are considered malformed.

---------

Co-authored-by: Carlos Sánchez López <1175054+carlossanlop@users.noreply.github.com>
---
 .../src/System/Formats/Tar/TarHeader.Write.cs |   97 +-
 .../tests/TarEntry/GnuTarEntry.Tests.cs       | 1457 ++++++++++-------
 .../tests/TarWriter/TarWriter.Tests.cs        |   18 +-
 3 files changed, 891 insertions(+), 681 deletions(-)

diff --git a/src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHeader.Write.cs b/src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHeader.Write.cs
index baffefad104b9c..dd7e15753cf0bb 100644
--- a/src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHeader.Write.cs
+++ b/src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHeader.Write.cs
@@ -354,6 +354,13 @@ internal async Task WriteAsPaxAsync(Stream archiveStream, Memory<byte> buffer, C
                 await WriteWithSeekableDataStreamAsync(TarEntryFormat.Pax, archiveStream, buffer, cancellationToken).ConfigureAwait(false);
             }
         }
+        // Checks if the linkname string is too long to fit in the regular header field.
+        // .NET strings do not include a null terminator by default, need to add it manually and also consider it for the length.
+        private bool IsLinkNameTooLongForRegularField() => _linkName != null && (Encoding.UTF8.GetByteCount(_linkName) + 1) > FieldLengths.LinkName;
+
+        // Checks if the name string is too long to fit in the regular header field.
+        // .NET strings do not include a null terminator by default, need to add it manually and also consider it for the length.
+        private bool IsNameTooLongForRegularField() => (Encoding.UTF8.GetByteCount(_name) + 1) > FieldLengths.Name;
 
         // Writes the current header as a Gnu entry into the archive stream.
         // Makes sure to add the preceding LongLink and/or LongPath entries if necessary, before the actual entry.
@@ -361,19 +368,19 @@ internal void WriteAsGnu(Stream archiveStream, Span<byte> buffer)
         {
             Debug.Assert(archiveStream.CanSeek || _dataStream == null || _dataStream.CanSeek);
 
-            // First, we determine if we need a preceding LongLink, and write it if needed
-            if (_linkName != null && Encoding.UTF8.GetByteCount(_linkName) > FieldLengths.LinkName)
+            if (IsLinkNameTooLongForRegularField())
             {
-                TarHeader longLinkHeader = GetGnuLongMetadataHeader(TarEntryType.LongLink, _linkName);
+                // Linkname is too long for the regular header field, create a longlink entry where the linkname will be stored.
+                TarHeader longLinkHeader = GetGnuLongLinkMetadataHeader();
                 Debug.Assert(longLinkHeader._dataStream != null && longLinkHeader._dataStream.CanSeek); // We generate the long metadata data stream, should always be seekable
                 longLinkHeader.WriteWithSeekableDataStream(TarEntryFormat.Gnu, archiveStream, buffer);
                 buffer.Clear(); // Reset it to reuse it
             }
 
-            // Second, we determine if we need a preceding LongPath, and write it if needed
-            if (Encoding.UTF8.GetByteCount(_name) > FieldLengths.Name)
+            if (IsNameTooLongForRegularField())
             {
-                TarHeader longPathHeader = GetGnuLongMetadataHeader(TarEntryType.LongPath, _name);
+                // Name is too long for the regular header field, create a longpath entry where the name will be stored.
+                TarHeader longPathHeader = GetGnuLongPathMetadataHeader();
                 Debug.Assert(longPathHeader._dataStream != null && longPathHeader._dataStream.CanSeek); // We generate the long metadata data stream, should always be seekable
                 longPathHeader.WriteWithSeekableDataStream(TarEntryFormat.Gnu, archiveStream, buffer);
                 buffer.Clear(); // Reset it to reuse it
@@ -397,19 +404,19 @@ internal async Task WriteAsGnuAsync(Stream archiveStream, Memory<byte> buffer, C
             Debug.Assert(archiveStream.CanSeek || _dataStream == null || _dataStream.CanSeek);
             cancellationToken.ThrowIfCancellationRequested();
 
-            // First, we determine if we need a preceding LongLink, and write it if needed
-            if (_linkName != null && Encoding.UTF8.GetByteCount(_linkName) > FieldLengths.LinkName)
+            if (IsLinkNameTooLongForRegularField())
             {
-                TarHeader longLinkHeader = GetGnuLongMetadataHeader(TarEntryType.LongLink, _linkName);
+                // Linkname is too long for the regular header field, create a longlink entry where the linkname will be stored.
+                TarHeader longLinkHeader = GetGnuLongLinkMetadataHeader();
                 Debug.Assert(longLinkHeader._dataStream != null && longLinkHeader._dataStream.CanSeek); // We generate the long metadata data stream, should always be seekable
                 await longLinkHeader.WriteWithSeekableDataStreamAsync(TarEntryFormat.Gnu, archiveStream, buffer, cancellationToken).ConfigureAwait(false);
                 buffer.Span.Clear(); // Reset it to reuse it
             }
 
-            // Second, we determine if we need a preceding LongPath, and write it if needed
-            if (Encoding.UTF8.GetByteCount(_name) > FieldLengths.Name)
+            if (IsNameTooLongForRegularField())
             {
-                TarHeader longPathHeader = GetGnuLongMetadataHeader(TarEntryType.LongPath, _name);
+                // Name is too long for the regular header field, create a longpath entry where the name will be stored.
+                TarHeader longPathHeader = GetGnuLongPathMetadataHeader();
                 Debug.Assert(longPathHeader._dataStream != null && longPathHeader._dataStream.CanSeek); // We generate the long metadata data stream, should always be seekable
                 await longPathHeader.WriteWithSeekableDataStreamAsync(TarEntryFormat.Gnu, archiveStream, buffer, cancellationToken).ConfigureAwait(false);
                 buffer.Span.Clear(); // Reset it to reuse it
@@ -426,8 +433,30 @@ internal async Task WriteAsGnuAsync(Stream archiveStream, Memory<byte> buffer, C
             }
         }
 
+        private static MemoryStream GetLongMetadataStream(string text)
+        {
+            MemoryStream data = new MemoryStream();
+            data.Write(Encoding.UTF8.GetBytes(text));
+            data.WriteByte(0); // Add a null terminator at the end of the string, _size will be calculated later
+            data.Position = 0;
+            return data;
+        }
+
+        private TarHeader GetGnuLongLinkMetadataHeader()
+        {
+            Debug.Assert(_linkName != null);
+            MemoryStream dataStream = GetLongMetadataStream(_linkName);
+            return GetGnuLongMetadataHeader(dataStream, TarEntryType.LongLink, _uid, _gid, _uName, _gName);
+        }
+
+        private TarHeader GetGnuLongPathMetadataHeader()
+        {
+            MemoryStream dataStream = GetLongMetadataStream(_name);
+            return GetGnuLongMetadataHeader(dataStream, TarEntryType.LongPath, _uid, _gid, _uName, _gName);
+        }
+
         // Creates and returns a GNU long metadata header, with the specified long text written into its data stream (seekable).
-        private static TarHeader GetGnuLongMetadataHeader(TarEntryType entryType, string longText)
+        private static TarHeader GetGnuLongMetadataHeader(MemoryStream dataStream, TarEntryType entryType, int mainEntryUid, int mainEntryGid, string? mainEntryUname, string? mainEntryGname)
         {
             Debug.Assert(entryType is TarEntryType.LongPath or TarEntryType.LongLink);
 
@@ -435,11 +464,15 @@ private static TarHeader GetGnuLongMetadataHeader(TarEntryType entryType, string
             {
                 _name = GnuLongMetadataName, // Same name for both longpath or longlink
                 _mode = TarHelpers.GetDefaultMode(entryType),
-                _uid = 0,
-                _gid = 0,
-                _mTime = DateTimeOffset.MinValue, // 0
+                _uid = mainEntryUid,
+                _gid = mainEntryGid,
+                _mTime = DateTimeOffset.UnixEpoch, // 0
                 _typeFlag = entryType,
-                _dataStream = new MemoryStream(Encoding.UTF8.GetBytes(longText))
+                _dataStream = dataStream,
+                _uName = mainEntryUname,
+                _gName = mainEntryGname,
+                _aTime = DateTimeOffset.UnixEpoch, // 0
+                _cTime = DateTimeOffset.UnixEpoch, // 0
             };
         }
 
@@ -614,17 +647,17 @@ private int WriteCommonFields(Span<byte> buffer, TarEntryType actualEntryType)
 
             int checksum = 0;
 
-            if (_mode > 0)
+            if (_mode >= 0)
             {
                 checksum += FormatNumeric(_mode, buffer.Slice(FieldLocations.Mode, FieldLengths.Mode));
             }
 
-            if (_uid > 0)
+            if (_uid >= 0)
             {
                 checksum += FormatNumeric(_uid, buffer.Slice(FieldLocations.Uid, FieldLengths.Uid));
             }
 
-            if (_gid > 0)
+            if (_gid >= 0)
             {
                 checksum += FormatNumeric(_gid, buffer.Slice(FieldLocations.Gid, FieldLengths.Gid));
             }
@@ -750,8 +783,8 @@ private int WritePosixAndGnuSharedFields(Span<byte> buffer)
         // Saves the gnu-specific fields into the specified spans.
         private int WriteGnuFields(Span<byte> buffer)
         {
-            int checksum = WriteAsGnuTimestamp(_aTime, buffer.Slice(FieldLocations.ATime, FieldLengths.ATime));
-            checksum += WriteAsGnuTimestamp(_cTime, buffer.Slice(FieldLocations.CTime, FieldLengths.CTime));
+            int checksum = WriteAsTimestamp(_aTime, buffer.Slice(FieldLocations.ATime, FieldLengths.ATime));
+            checksum += WriteAsTimestamp(_cTime, buffer.Slice(FieldLocations.CTime, FieldLengths.CTime));
 
             if (_gnuUnusedBytes != null)
             {
@@ -1060,7 +1093,6 @@ private static int Checksum(ReadOnlySpan<byte> bytes)
             }
             return checksum;
         }
-
         private int FormatNumeric(int value, Span<byte> destination)
         {
             Debug.Assert(destination.Length == 8, "8 byte field expected.");
@@ -1118,6 +1150,7 @@ private static int FormatOctal(long value, Span<byte> destination)
             Span<byte> digits = stackalloc byte[32]; // longer than any possible octal formatting of a ulong
 
             int i = digits.Length - 1;
+
             while (true)
             {
                 digits[i] = (byte)('0' + (remaining % 8));
@@ -1136,24 +1169,6 @@ private int WriteAsTimestamp(DateTimeOffset timestamp, Span<byte> destination)
             return FormatNumeric(unixTimeSeconds, destination);
         }
 
-        // Writes the specified DateTimeOffset's Unix time seconds, and returns its checksum.
-        // If the timestamp is UnixEpoch, it writes 0s into the destination span.
-        private int WriteAsGnuTimestamp(DateTimeOffset timestamp, Span<byte> destination)
-        {
-            if (timestamp == DateTimeOffset.UnixEpoch)
-            {
-#if DEBUG
-                for (int i = 0; i < destination.Length; i++)
-                {
-                    Debug.Assert(destination[i] == 0, "Destination span should be zeroed.");
-                }
-#endif
-                return 0;
-            }
-
-            return WriteAsTimestamp(timestamp, destination);
-        }
-
         // Writes the specified text as an UTF8 string aligned to the left, and returns its checksum.
         private static int WriteAsUtf8String(ReadOnlySpan<char> text, Span<byte> buffer)
         {
diff --git a/src/libraries/System.Formats.Tar/tests/TarEntry/GnuTarEntry.Tests.cs b/src/libraries/System.Formats.Tar/tests/TarEntry/GnuTarEntry.Tests.cs
index 4d9153ac57ce00..bc80d89becbc06 100644
--- a/src/libraries/System.Formats.Tar/tests/TarEntry/GnuTarEntry.Tests.cs
+++ b/src/libraries/System.Formats.Tar/tests/TarEntry/GnuTarEntry.Tests.cs
@@ -1,8 +1,12 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections;
+using System.Collections.Generic;
 using System.IO;
+using System.IO.Compression;
 using System.Linq;
+using System.Numerics;
 using System.Text;
 using System.Threading.Tasks;
 using Xunit;
@@ -10,742 +14,931 @@
 namespace System.Formats.Tar.Tests
 {
     public class GnuTarEntry_Tests : TarTestsBase
+{
+    [Fact]
+    public void Constructor_InvalidEntryName()
     {
-        [Fact]
-        public void Constructor_InvalidEntryName()
-        {
-            Assert.Throws<ArgumentNullException>(() => new GnuTarEntry(TarEntryType.RegularFile, entryName: null));
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.RegularFile, entryName: string.Empty));
-        }
+        Assert.Throws<ArgumentNullException>(() => new GnuTarEntry(TarEntryType.RegularFile, entryName: null));
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.RegularFile, entryName: string.Empty));
+    }
 
-        [Fact]
-        public void Constructor_UnsupportedEntryTypes()
-        {
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry((TarEntryType)byte.MaxValue, InitialEntryName));
+    [Fact]
+    public void Constructor_UnsupportedEntryTypes()
+    {
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry((TarEntryType)byte.MaxValue, InitialEntryName));
+
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.ExtendedAttributes, InitialEntryName));
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.GlobalExtendedAttributes, InitialEntryName));
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.V7RegularFile, InitialEntryName));
+
+        // These are specific to GNU, but currently the user cannot create them manually
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.ContiguousFile, InitialEntryName));
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.DirectoryList, InitialEntryName));
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.MultiVolume, InitialEntryName));
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.RenamedOrSymlinked, InitialEntryName));
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.SparseFile, InitialEntryName));
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.TapeVolume, InitialEntryName));
+
+        // The user should not create these entries manually
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.LongLink, InitialEntryName));
+        Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.LongPath, InitialEntryName));
+    }
 
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.ExtendedAttributes, InitialEntryName));
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.GlobalExtendedAttributes, InitialEntryName));
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.V7RegularFile, InitialEntryName));
+    [Fact]
+    public void SupportedEntryType_RegularFile()
+    {
+        GnuTarEntry regularFile = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
+        SetRegularFile(regularFile);
+        VerifyRegularFile(regularFile, isWritable: true);
+    }
 
-            // These are specific to GNU, but currently the user cannot create them manually
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.ContiguousFile, InitialEntryName));
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.DirectoryList, InitialEntryName));
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.MultiVolume, InitialEntryName));
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.RenamedOrSymlinked, InitialEntryName));
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.SparseFile, InitialEntryName));
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.TapeVolume, InitialEntryName));
+    [Fact]
+    public void SupportedEntryType_Directory()
+    {
+        GnuTarEntry directory = new GnuTarEntry(TarEntryType.Directory, InitialEntryName);
+        SetDirectory(directory);
+        VerifyDirectory(directory);
+    }
 
-            // The user should not create these entries manually
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.LongLink, InitialEntryName));
-            Assert.Throws<ArgumentException>(() => new GnuTarEntry(TarEntryType.LongPath, InitialEntryName));
-        }
+    [Fact]
+    public void SupportedEntryType_HardLink()
+    {
+        GnuTarEntry hardLink = new GnuTarEntry(TarEntryType.HardLink, InitialEntryName);
+        SetHardLink(hardLink);
+        VerifyHardLink(hardLink);
+    }
 
-        [Fact]
-        public void SupportedEntryType_RegularFile()
+    [Fact]
+    public void SupportedEntryType_SymbolicLink()
+    {
+        GnuTarEntry symbolicLink = new GnuTarEntry(TarEntryType.SymbolicLink, InitialEntryName);
+        SetSymbolicLink(symbolicLink);
+        VerifySymbolicLink(symbolicLink);
+    }
+
+    [Fact]
+    public void SupportedEntryType_BlockDevice()
+    {
+        GnuTarEntry blockDevice = new GnuTarEntry(TarEntryType.BlockDevice, InitialEntryName);
+        SetBlockDevice(blockDevice);
+        VerifyBlockDevice(blockDevice);
+    }
+
+    [Fact]
+    public void SupportedEntryType_CharacterDevice()
+    {
+        GnuTarEntry characterDevice = new GnuTarEntry(TarEntryType.CharacterDevice, InitialEntryName);
+        SetCharacterDevice(characterDevice);
+        VerifyCharacterDevice(characterDevice);
+    }
+
+    [Fact]
+    public void SupportedEntryType_Fifo()
+    {
+        GnuTarEntry fifo = new GnuTarEntry(TarEntryType.Fifo, InitialEntryName);
+        SetFifo(fifo);
+        VerifyFifo(fifo);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void DataOffset_RegularFile(bool canSeek)
+    {
+        using MemoryStream ms = new();
+        using (TarWriter writer = new(ms, leaveOpen: true))
         {
-            GnuTarEntry regularFile = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
-            SetRegularFile(regularFile);
-            VerifyRegularFile(regularFile, isWritable: true);
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
+            entry.DataStream = new MemoryStream();
+            entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
+            entry.DataStream.Position = 0;
+            writer.WriteEntry(entry);
         }
+        ms.Position = 0;
 
-        [Fact]
-        public void SupportedEntryType_Directory()
+        using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
+        using TarReader reader = new(streamToRead);
+        TarEntry actualEntry = reader.GetNextEntry();
+        Assert.NotNull(actualEntry);
+
+        // Then it writes the actual regular file entry, containing:
+        // * 512 bytes of the regular tar header
+        // Totalling 2560.
+        // The regular file data section starts on the next byte.
+        long expectedDataOffset = canSeek ? 512 : -1;
+        Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
+
+        if (canSeek)
         {
-            GnuTarEntry directory = new GnuTarEntry(TarEntryType.Directory, InitialEntryName);
-            SetDirectory(directory);
-            VerifyDirectory(directory);
+            ms.Position = actualEntry.DataOffset;
+            byte actualData = (byte)ms.ReadByte();
+            Assert.Equal(ExpectedOffsetDataSingleByte, actualData);
         }
+    }
 
-        [Fact]
-        public void SupportedEntryType_HardLink()
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task DataOffset_RegularFile_Async(bool canSeek)
+    {
+        await using MemoryStream ms = new();
+        await using (TarWriter writer = new(ms, leaveOpen: true))
         {
-            GnuTarEntry hardLink = new GnuTarEntry(TarEntryType.HardLink, InitialEntryName);
-            SetHardLink(hardLink);
-            VerifyHardLink(hardLink);
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
+            entry.DataStream = new MemoryStream();
+            entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
+            entry.DataStream.Position = 0;
+            await writer.WriteEntryAsync(entry);
         }
+        ms.Position = 0;
 
-        [Fact]
-        public void SupportedEntryType_SymbolicLink()
+        await using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
+        await using TarReader reader = new(streamToRead);
+        TarEntry actualEntry = await reader.GetNextEntryAsync();
+        Assert.NotNull(actualEntry);
+
+        // Then it writes the actual regular file entry, containing:
+        // * 512 bytes of the regular tar header
+        // Totalling 2560.
+        // The regular file data section starts on the next byte.
+        long expectedDataOffset = canSeek ? 512 : -1;
+        Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
+
+        if (canSeek)
         {
-            GnuTarEntry symbolicLink = new GnuTarEntry(TarEntryType.SymbolicLink, InitialEntryName);
-            SetSymbolicLink(symbolicLink);
-            VerifySymbolicLink(symbolicLink);
+            ms.Position = actualEntry.DataOffset;
+            byte actualData = (byte)ms.ReadByte();
+            Assert.Equal(ExpectedOffsetDataSingleByte, actualData);
         }
+    }
 
-        [Fact]
-        public void SupportedEntryType_BlockDevice()
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void DataOffset_RegularFile_LongPath(bool canSeek)
+    {
+        using MemoryStream ms = new();
+        using (TarWriter writer = new(ms, leaveOpen: true))
         {
-            GnuTarEntry blockDevice = new GnuTarEntry(TarEntryType.BlockDevice, InitialEntryName);
-            SetBlockDevice(blockDevice);
-            VerifyBlockDevice(blockDevice);
+            string veryLongName = new string('a', 1234); // Forces using a GNU LongPath entry
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, veryLongName);
+            entry.DataStream = new MemoryStream();
+            entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
+            entry.DataStream.Position = 0;
+            writer.WriteEntry(entry);
         }
+        ms.Position = 0;
+
+        using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
+        using TarReader reader = new(streamToRead);
+        TarEntry actualEntry = reader.GetNextEntry();
+        Assert.NotNull(actualEntry);
+
+        // GNU first writes the long path entry, containing:
+        // * 512 bytes of the regular tar header
+        // * 1234 bytes for the data section containing the full long path
+        // * 302 bytes of padding
+        // Then it writes the actual regular file entry, containing:
+        // * 512 bytes of the regular tar header
+        // Totalling 2560.
+        // The regular file data section starts on the next byte.
+        long expectedDataOffset = canSeek ? 2560 : -1;
+        Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
+    }
 
-        [Fact]
-        public void SupportedEntryType_CharacterDevice()
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task DataOffset_RegularFile_LongPath_Async(bool canSeek)
+    {
+        await using MemoryStream ms = new();
+        await using (TarWriter writer = new(ms, leaveOpen: true))
         {
-            GnuTarEntry characterDevice = new GnuTarEntry(TarEntryType.CharacterDevice, InitialEntryName);
-            SetCharacterDevice(characterDevice);
-            VerifyCharacterDevice(characterDevice);
+            string veryLongName = new string('a', 1234); // Forces using a GNU LongPath entry
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, veryLongName);
+            entry.DataStream = new MemoryStream();
+            entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
+            entry.DataStream.Position = 0;
+            await writer.WriteEntryAsync(entry);
         }
+        ms.Position = 0;
+
+        await using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
+        await using TarReader reader = new(streamToRead);
+        TarEntry actualEntry = await reader.GetNextEntryAsync();
+        Assert.NotNull(actualEntry);
+
+        // GNU first writes the long path entry, containing:
+        // * 512 bytes of the regular tar header
+        // * 1234 bytes for the data section containing the full long path
+        // * 302 bytes of padding
+        // Then it writes the actual regular file entry, containing:
+        // * 512 bytes of the regular tar header
+        // Totalling 2560.
+        // The regular file data section starts on the next byte.
+        long expectedDataOffset = canSeek ? 2560 : -1;
+        Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
+    }
 
-        [Fact]
-        public void SupportedEntryType_Fifo()
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void DataOffset_RegularFile_LongLink(bool canSeek)
+    {
+        using MemoryStream ms = new();
+        using (TarWriter writer = new(ms, leaveOpen: true))
         {
-            GnuTarEntry fifo = new GnuTarEntry(TarEntryType.Fifo, InitialEntryName);
-            SetFifo(fifo);
-            VerifyFifo(fifo);
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.SymbolicLink, InitialEntryName);
+            entry.LinkName = new string('a', 1234); // Forces using a GNU LongLink entry
+            writer.WriteEntry(entry);
         }
-
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public void DataOffset_RegularFile(bool canSeek)
+        ms.Position = 0;
+
+        using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
+        using TarReader reader = new(streamToRead);
+        TarEntry actualEntry = reader.GetNextEntry();
+        Assert.NotNull(actualEntry);
+
+        // GNU first writes the long link entry, containing:
+        // * 512 bytes of the regular tar header
+        // * 1234 bytes for the data section containing the full long link
+        // * 302 bytes of padding
+        // Then it writes the actual regular file entry, containing:
+        // * 512 bytes of the regular tar header
+        // Totalling 2560.
+        // The regular file data section starts on the next byte.
+        long expectedDataOffset = canSeek ? 2560 : -1;
+        Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
+    }
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task DataOffset_RegularFile_LongLink_Async(bool canSeek)
+    {
+        await using MemoryStream ms = new();
+        await using (TarWriter writer = new(ms, leaveOpen: true))
         {
-            using MemoryStream ms = new();
-            using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
-                entry.DataStream = new MemoryStream();
-                entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
-                entry.DataStream.Position = 0;
-                writer.WriteEntry(entry);
-            }
-            ms.Position = 0;
-
-            using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
-            using TarReader reader = new(streamToRead);
-            TarEntry actualEntry = reader.GetNextEntry();
-            Assert.NotNull(actualEntry);
-
-            // Then it writes the actual regular file entry, containing:
-            // * 512 bytes of the regular tar header
-            // Totalling 2560.
-            // The regular file data section starts on the next byte.
-            long expectedDataOffset = canSeek ? 512 : -1;
-            Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
-
-            if (canSeek)
-            {
-                ms.Position = actualEntry.DataOffset;
-                byte actualData = (byte)ms.ReadByte();
-                Assert.Equal(ExpectedOffsetDataSingleByte, actualData);
-            }
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.SymbolicLink, InitialEntryName);
+            entry.LinkName = new string('b', 1234); // Forces using a GNU LongLink entry
+            await writer.WriteEntryAsync(entry);
         }
+        ms.Position = 0;
+
+        await using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
+        await using TarReader reader = new(streamToRead);
+        TarEntry actualEntry = await reader.GetNextEntryAsync();
+        Assert.NotNull(actualEntry);
+
+        // GNU first writes the long link entry, containing:
+        // * 512 bytes of the regular tar header
+        // * 1234 bytes for the data section containing the full long link
+        // * 302 bytes of padding
+        // Then it writes the actual regular file entry, containing:
+        // * 512 bytes of the regular tar header
+        // Totalling 2560.
+        // The regular file data section starts on the next byte.
+        long expectedDataOffset = canSeek ? 2560 : -1;
+        Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
+    }
 
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public async Task DataOffset_RegularFile_Async(bool canSeek)
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void DataOffset_RegularFile_LongLink_LongPath(bool canSeek)
+    {
+        using MemoryStream ms = new();
+        using (TarWriter writer = new(ms, leaveOpen: true))
         {
-            await using MemoryStream ms = new();
-            await using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
-                entry.DataStream = new MemoryStream();
-                entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
-                entry.DataStream.Position = 0;
-                await writer.WriteEntryAsync(entry);
-            }
-            ms.Position = 0;
+            string veryLongName = new string('a', 1234); // Forces using a GNU LongPath entry
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongName);
+            entry.LinkName = new string('b', 1234); // Forces using a GNU LongLink entry
+            writer.WriteEntry(entry);
+        }
+        ms.Position = 0;
+
+        using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
+        using TarReader reader = new(streamToRead);
+        TarEntry actualEntry = reader.GetNextEntry();
+        Assert.NotNull(actualEntry);
+
+        // GNU first writes the long link and long path entries, containing:
+        // * 512 bytes of the regular long link tar header
+        // * 1234 bytes for the data section containing the full long link
+        // * 302 bytes of padding
+        // * 512 bytes of the regular long path tar header
+        // * 1234 bytes for the data section containing the full long path
+        // * 302 bytes of padding
+        // Then it writes the actual entry, containing:
+        // * 512 bytes of the regular tar header
+        // Totalling 4608.
+        // The data section starts on the next byte.
+        long expectedDataOffset = canSeek ? 4608 : -1;
+        Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
+    }
 
-            await using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
-            await using TarReader reader = new(streamToRead);
-            TarEntry actualEntry = await reader.GetNextEntryAsync();
-            Assert.NotNull(actualEntry);
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task DataOffset_RegularFile_LongLink_LongPath_Async(bool canSeek)
+    {
+        await using MemoryStream ms = new();
+        await using (TarWriter writer = new(ms, leaveOpen: true))
+        {
+            string veryLongName = new string('a', 1234); // Forces using a GNU LongPath entry
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongName);
+            entry.LinkName = new string('b', 1234); // Forces using a GNU LongLink entry
+            await writer.WriteEntryAsync(entry);
+        }
+        ms.Position = 0;
+
+        await using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
+        await using TarReader reader = new(streamToRead);
+        TarEntry actualEntry = await reader.GetNextEntryAsync();
+        Assert.NotNull(actualEntry);
+
+        // GNU first writes the long link and long path entries, containing:
+        // * 512 bytes of the regular long link tar header
+        // * 1234 bytes for the data section containing the full long link
+        // * 302 bytes of padding
+        // * 512 bytes of the regular long path tar header
+        // * 1234 bytes for the data section containing the full long path
+        // * 302 bytes of padding
+        // Then it writes the actual entry, containing:
+        // * 512 bytes of the regular tar header
+        // Totalling 4608.
+        // The data section starts on the next byte.
+        long expectedDataOffset = canSeek ? 4608 : -1;
+        Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
+    }
 
-            // Then it writes the actual regular file entry, containing:
-            // * 512 bytes of the regular tar header
-            // Totalling 2560.
-            // The regular file data section starts on the next byte.
-            long expectedDataOffset = canSeek ? 512 : -1;
-            Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
+    [Fact]
+    public void DataOffset_BeforeAndAfterArchive()
+    {
+        GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
+        Assert.Equal(-1, entry.DataOffset);
+        entry.DataStream = new MemoryStream();
+        entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
+        entry.DataStream.Position = 0; // The data stream is written to the archive from the current position
+
+        using MemoryStream ms = new();
+        using TarWriter writer = new(ms);
+        writer.WriteEntry(entry);
+        Assert.Equal(512, entry.DataOffset);
+
+        // Write it again, the offset should now point to the second written entry
+        // First entry 512 (header) + 1 (data) + 511 (padding)
+        // Second entry 512 (header)
+        // 512 + 512 + 512 = 1536
+        writer.WriteEntry(entry);
+        Assert.Equal(1536, entry.DataOffset);
+    }
 
-            if (canSeek)
-            {
-                ms.Position = actualEntry.DataOffset;
-                byte actualData = (byte)ms.ReadByte();
-                Assert.Equal(ExpectedOffsetDataSingleByte, actualData);
-            }
-        }
+    [Fact]
+    public async Task DataOffset_BeforeAndAfterArchive_Async()
+    {
+        GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
+        Assert.Equal(-1, entry.DataOffset);
+
+        entry.DataStream = new MemoryStream();
+        entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
+        entry.DataStream.Position = 0; // The data stream is written to the archive from the current position
+
+        await using MemoryStream ms = new();
+        await using TarWriter writer = new(ms);
+        await writer.WriteEntryAsync(entry);
+        Assert.Equal(512, entry.DataOffset);
+
+        // Write it again, the offset should now point to the second written entry
+        // First entry 512 (header) + 1 (data) + 511 (padding)
+        // Second entry 512 (header)
+        // 512 + 512 + 512 = 1536
+        await writer.WriteEntryAsync(entry);
+        Assert.Equal(1536, entry.DataOffset);
+    }
 
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public void DataOffset_RegularFile_LongPath(bool canSeek)
-        {
-            using MemoryStream ms = new();
-            using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                string veryLongName = new string('a', 1234); // Forces using a GNU LongPath entry
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, veryLongName);
-                entry.DataStream = new MemoryStream();
-                entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
-                entry.DataStream.Position = 0;
-                writer.WriteEntry(entry);
-            }
-            ms.Position = 0;
-
-            using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
-            using TarReader reader = new(streamToRead);
-            TarEntry actualEntry = reader.GetNextEntry();
-            Assert.NotNull(actualEntry);
-
-            // GNU first writes the long path entry, containing:
-            // * 512 bytes of the regular tar header
-            // * 1234 bytes for the data section containing the full long path
-            // * 302 bytes of padding
-            // Then it writes the actual regular file entry, containing:
-            // * 512 bytes of the regular tar header
-            // Totalling 2560.
-            // The regular file data section starts on the next byte.
-            long expectedDataOffset = canSeek ? 2560 : -1;
-            Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
-        }
-
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public async Task DataOffset_RegularFile_LongPath_Async(bool canSeek)
-        {
-            await using MemoryStream ms = new();
-            await using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                string veryLongName = new string('a', 1234); // Forces using a GNU LongPath entry
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, veryLongName);
-                entry.DataStream = new MemoryStream();
-                entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
-                entry.DataStream.Position = 0;
-                await writer.WriteEntryAsync(entry);
-            }
-            ms.Position = 0;
-
-            await using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
-            await using TarReader reader = new(streamToRead);
-            TarEntry actualEntry = await reader.GetNextEntryAsync();
-            Assert.NotNull(actualEntry);
-
-            // GNU first writes the long path entry, containing:
-            // * 512 bytes of the regular tar header
-            // * 1234 bytes for the data section containing the full long path
-            // * 302 bytes of padding
-            // Then it writes the actual regular file entry, containing:
-            // * 512 bytes of the regular tar header
-            // Totalling 2560.
-            // The regular file data section starts on the next byte.
-            long expectedDataOffset = canSeek ? 2560 : -1;
-            Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
-        }
-
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public void DataOffset_RegularFile_LongLink(bool canSeek)
-        {
-            using MemoryStream ms = new();
-            using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.SymbolicLink, InitialEntryName);
-                entry.LinkName = new string('a', 1234); // Forces using a GNU LongLink entry
-                writer.WriteEntry(entry);
-            }
-            ms.Position = 0;
-
-            using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
-            using TarReader reader = new(streamToRead);
-            TarEntry actualEntry = reader.GetNextEntry();
-            Assert.NotNull(actualEntry);
-
-            // GNU first writes the long link entry, containing:
-            // * 512 bytes of the regular tar header
-            // * 1234 bytes for the data section containing the full long link
-            // * 302 bytes of padding
-            // Then it writes the actual regular file entry, containing:
-            // * 512 bytes of the regular tar header
-            // Totalling 2560.
-            // The regular file data section starts on the next byte.
-            long expectedDataOffset = canSeek ? 2560 : -1;
-            Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
-        }
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public async Task DataOffset_RegularFile_LongLink_Async(bool canSeek)
-        {
-            await using MemoryStream ms = new();
-            await using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.SymbolicLink, InitialEntryName);
-                entry.LinkName = new string('b', 1234); // Forces using a GNU LongLink entry
-                await writer.WriteEntryAsync(entry);
-            }
-            ms.Position = 0;
-
-            await using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
-            await using TarReader reader = new(streamToRead);
-            TarEntry actualEntry = await reader.GetNextEntryAsync();
-            Assert.NotNull(actualEntry);
-
-            // GNU first writes the long link entry, containing:
-            // * 512 bytes of the regular tar header
-            // * 1234 bytes for the data section containing the full long link
-            // * 302 bytes of padding
-            // Then it writes the actual regular file entry, containing:
-            // * 512 bytes of the regular tar header
-            // Totalling 2560.
-            // The regular file data section starts on the next byte.
-            long expectedDataOffset = canSeek ? 2560 : -1;
-            Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
-        }
-
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public void DataOffset_RegularFile_LongLink_LongPath(bool canSeek)
-        {
-            using MemoryStream ms = new();
-            using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                string veryLongName = new string('a', 1234); // Forces using a GNU LongPath entry
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongName);
-                entry.LinkName = new string('b', 1234); // Forces using a GNU LongLink entry
-                writer.WriteEntry(entry);
-            }
-            ms.Position = 0;
-
-            using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
-            using TarReader reader = new(streamToRead);
-            TarEntry actualEntry = reader.GetNextEntry();
-            Assert.NotNull(actualEntry);
-
-            // GNU first writes the long link and long path entries, containing:
-            // * 512 bytes of the regular long link tar header
-            // * 1234 bytes for the data section containing the full long link
-            // * 302 bytes of padding
-            // * 512 bytes of the regular long path tar header
-            // * 1234 bytes for the data section containing the full long path
-            // * 302 bytes of padding
-            // Then it writes the actual entry, containing:
-            // * 512 bytes of the regular tar header
-            // Totalling 4608.
-            // The data section starts on the next byte.
-            long expectedDataOffset = canSeek ? 4608 : -1;
-            Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
-        }
-
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public async Task DataOffset_RegularFile_LongLink_LongPath_Async(bool canSeek)
-        {
-            await using MemoryStream ms = new();
-            await using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                string veryLongName = new string('a', 1234); // Forces using a GNU LongPath entry
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongName);
-                entry.LinkName = new string('b', 1234); // Forces using a GNU LongLink entry
-                await writer.WriteEntryAsync(entry);
-            }
-            ms.Position = 0;
-
-            await using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
-            await using TarReader reader = new(streamToRead);
-            TarEntry actualEntry = await reader.GetNextEntryAsync();
-            Assert.NotNull(actualEntry);
-
-            // GNU first writes the long link and long path entries, containing:
-            // * 512 bytes of the regular long link tar header
-            // * 1234 bytes for the data section containing the full long link
-            // * 302 bytes of padding
-            // * 512 bytes of the regular long path tar header
-            // * 1234 bytes for the data section containing the full long path
-            // * 302 bytes of padding
-            // Then it writes the actual entry, containing:
-            // * 512 bytes of the regular tar header
-            // Totalling 4608.
-            // The data section starts on the next byte.
-            long expectedDataOffset = canSeek ? 4608 : -1;
-            Assert.Equal(expectedDataOffset, actualEntry.DataOffset);
-        }
-
-        [Fact]
-        public void DataOffset_BeforeAndAfterArchive()
+    [Fact]
+    public void DataOffset_UnseekableDataStream()
+    {
+        using MemoryStream ms = new();
+        using (TarWriter writer = new(ms, leaveOpen: true))
         {
             GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
             Assert.Equal(-1, entry.DataOffset);
-            entry.DataStream = new MemoryStream();
-            entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
-            entry.DataStream.Position = 0; // The data stream is written to the archive from the current position
 
-            using MemoryStream ms = new();
-            using TarWriter writer = new(ms);
-            writer.WriteEntry(entry);
-            Assert.Equal(512, entry.DataOffset);
+            using MemoryStream dataStream = new();
+            dataStream.WriteByte(ExpectedOffsetDataSingleByte);
+            dataStream.Position = 0;
+            using WrappedStream wds = new(dataStream, canWrite: true, canRead: true, canSeek: false);
+            entry.DataStream = wds;
 
-            // Write it again, the offset should now point to the second written entry
-            // First entry 512 (header) + 1 (data) + 511 (padding)
-            // Second entry 512 (header)
-            // 512 + 512 + 512 = 1536
             writer.WriteEntry(entry);
-            Assert.Equal(1536, entry.DataOffset);
         }
+        ms.Position = 0;
+
+        using TarReader reader = new(ms);
+        TarEntry actualEntry = reader.GetNextEntry();
+        Assert.NotNull(actualEntry);
+        // Gnu header length is 512, data starts in the next position
+        Assert.Equal(512, actualEntry.DataOffset);
+    }
 
-        [Fact]
-        public async Task DataOffset_BeforeAndAfterArchive_Async()
+    [Fact]
+    public async Task DataOffset_UnseekableDataStream_Async()
+    {
+        await using MemoryStream ms = new();
+        await using (TarWriter writer = new(ms, leaveOpen: true))
         {
             GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
             Assert.Equal(-1, entry.DataOffset);
 
-            entry.DataStream = new MemoryStream();
-            entry.DataStream.WriteByte(ExpectedOffsetDataSingleByte);
-            entry.DataStream.Position = 0; // The data stream is written to the archive from the current position
+            await using MemoryStream dataStream = new();
+            dataStream.WriteByte(ExpectedOffsetDataSingleByte);
+            dataStream.Position = 0;
+            await using WrappedStream wds = new(dataStream, canWrite: true, canRead: true, canSeek: false);
+            entry.DataStream = wds;
 
-            await using MemoryStream ms = new();
-            await using TarWriter writer = new(ms);
             await writer.WriteEntryAsync(entry);
-            Assert.Equal(512, entry.DataOffset);
+        }
+        ms.Position = 0;
 
-            // Write it again, the offset should now point to the second written entry
-            // First entry 512 (header) + 1 (data) + 511 (padding)
-            // Second entry 512 (header)
-            // 512 + 512 + 512 = 1536
-            await writer.WriteEntryAsync(entry);
-            Assert.Equal(1536, entry.DataOffset);
+        await using TarReader reader = new(ms);
+        TarEntry actualEntry = await reader.GetNextEntryAsync();
+        Assert.NotNull(actualEntry);
+        // Gnu header length is 512, data starts in the next position
+        Assert.Equal(512, actualEntry.DataOffset);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void DataOffset_LongPath_LongLink_SecondEntry(bool canSeek)
+    {
+        string veryLongPathName = new string('a', 1234); // Forces using a GNU LongPath entry
+        string veryLongLinkName = new string('b', 1234); // Forces using a GNU LongLink entry
+
+        using MemoryStream ms = new();
+        using (TarWriter writer = new(ms, leaveOpen: true))
+        {
+            GnuTarEntry entry1 = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongPathName);
+            entry1.LinkName = veryLongLinkName;
+            writer.WriteEntry(entry1);
+
+            GnuTarEntry entry2 = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongPathName);
+            entry2.LinkName = veryLongLinkName;
+            writer.WriteEntry(entry2);
         }
+        ms.Position = 0;
+
+        using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
+        using TarReader reader = new(streamToRead);
+        TarEntry firstEntry = reader.GetNextEntry();
+        Assert.NotNull(firstEntry);
+        // GNU first writes the long link and long path entries, containing:
+        // * 512 bytes of the regular long link tar header
+        // * 1234 bytes for the data section containing the full long link
+        // * 302 bytes of padding
+        // * 512 bytes of the regular long path tar header
+        // * 1234 bytes for the data section containing the full long path
+        // * 302 bytes of padding
+        // Then it writes the actual regular file entry, containing:
+        // * 512 bytes of the regular tar header
+        // Totalling 4608.
+        // The regular file data section starts on the next byte.
+        long firstExpectedDataOffset = canSeek ? 4608 : -1;
+        Assert.Equal(firstExpectedDataOffset, firstEntry.DataOffset);
+
+        TarEntry secondEntry = reader.GetNextEntry();
+        Assert.NotNull(secondEntry);
+        // First entry (including its long link and long path entries) end at 4608 (no padding, empty, as symlink has no data)
+        // Second entry (including its long link and long path entries) data section starts one byte after 4608 + 4608 = 9216
+        long secondExpectedDataOffset = canSeek ? 9216 : -1;
+        Assert.Equal(secondExpectedDataOffset, secondEntry.DataOffset);
+    }
 
-        [Fact]
-        public void DataOffset_UnseekableDataStream()
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task DataOffset_LongPath_LongLink_SecondEntry_Async(bool canSeek)
+    {
+        string veryLongPathName = new string('a', 1234); // Forces using a GNU LongPath entry
+        string veryLongLinkName = new string('b', 1234); // Forces using a GNU LongLink entry
+
+        await using MemoryStream ms = new();
+        await using (TarWriter writer = new(ms, leaveOpen: true))
         {
-            using MemoryStream ms = new();
-            using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
-                Assert.Equal(-1, entry.DataOffset);
+            GnuTarEntry entry1 = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongPathName);
+            entry1.LinkName = veryLongLinkName;
+            await writer.WriteEntryAsync(entry1);
 
-                using MemoryStream dataStream = new();
-                dataStream.WriteByte(ExpectedOffsetDataSingleByte);
-                dataStream.Position = 0;
-                using WrappedStream wds = new(dataStream, canWrite: true, canRead: true, canSeek: false);
-                entry.DataStream = wds;
+            GnuTarEntry entry2 = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongPathName);
+            entry2.LinkName = veryLongLinkName;
+            await writer.WriteEntryAsync(entry2);
+        }
+        ms.Position = 0;
+
+        await using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
+        await using TarReader reader = new(streamToRead);
+        TarEntry firstEntry = await reader.GetNextEntryAsync();
+        Assert.NotNull(firstEntry);
+        // GNU first writes the long link and long path entries, containing:
+        // * 512 bytes of the regular long link tar header
+        // * 1234 bytes for the data section containing the full long link
+        // * 302 bytes of padding
+        // * 512 bytes of the regular long path tar header
+        // * 1234 bytes for the data section containing the full long path
+        // * 302 bytes of padding
+        // Then it writes the actual regular file entry, containing:
+        // * 512 bytes of the regular tar header
+        // Totalling 4608.
+        // The regular file data section starts on the next byte.
+        long firstExpectedDataOffset = canSeek ? 4608 : -1;
+        Assert.Equal(firstExpectedDataOffset, firstEntry.DataOffset);
+
+        TarEntry secondEntry = await reader.GetNextEntryAsync();
+        Assert.NotNull(secondEntry);
+        // First entry (including its long link and long path entries) end at 4608 (no padding, empty, as symlink has no data)
+        // Second entry (including its long link and long path entries) data section starts one byte after 4608 + 4608 = 9216
+        long secondExpectedDataOffset = canSeek ? 9216 : -1;
+        Assert.Equal(secondExpectedDataOffset, secondEntry.DataOffset);
+    }
 
-                writer.WriteEntry(entry);
-            }
-            ms.Position = 0;
+    [Fact]
+    public void UnusedBytesInSizeFieldShouldBeZeroChars()
+    {
+        // The GNU format sets the unused bytes in the size field to "0" characters.
 
-            using TarReader reader = new(ms);
-            TarEntry actualEntry = reader.GetNextEntry();
-            Assert.NotNull(actualEntry);
-            // Gnu header length is 512, data starts in the next position
-            Assert.Equal(512, actualEntry.DataOffset);
+        using MemoryStream ms = new();
+
+        using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
+        {
+            // Start with a regular file entry without data
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
+            writer.WriteEntry(entry);
         }
+        ms.Position = 0;
 
-        [Fact]
-        public async Task DataOffset_UnseekableDataStream_Async()
+        using (TarReader reader = new(ms, leaveOpen: true))
         {
-            await using MemoryStream ms = new();
-            await using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
-                Assert.Equal(-1, entry.DataOffset);
+            GnuTarEntry entry = reader.GetNextEntry() as GnuTarEntry;
+            Assert.NotNull(entry);
+            Assert.Equal(0, entry.Length);
+        }
+        ms.Position = 0;
+        ValidateUnusedBytesInSizeField(ms, 0);
+
+        ms.SetLength(0); // Reset the stream
+        byte[] data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; // 8 bytes of data means a size of 10 in octal
+        using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
+        {
+            // Start with a regular file entry with data
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
+            entry.DataStream = new MemoryStream(data);
+            writer.WriteEntry(entry);
+        }
 
-                await using MemoryStream dataStream = new();
-                dataStream.WriteByte(ExpectedOffsetDataSingleByte);
-                dataStream.Position = 0;
-                await using WrappedStream wds = new(dataStream, canWrite: true, canRead: true, canSeek: false);
-                entry.DataStream = wds;
+        ms.Position = 0;
+        using (TarReader reader = new(ms, leaveOpen: true))
+        {
+            GnuTarEntry entry = reader.GetNextEntry() as GnuTarEntry;
+            Assert.NotNull(entry);
+            Assert.Equal(data.Length, entry.Length);
+        }
+        ms.Position = 0;
+        ValidateUnusedBytesInSizeField(ms, data.Length);
+    }
 
-                await writer.WriteEntryAsync(entry);
-            }
-            ms.Position = 0;
+    [Fact]
+    public async Task UnusedBytesInSizeFieldShouldBeZeroChars_Async()
+    {
+        // The GNU format sets the unused bytes in the size field to "0" characters.
 
-            await using TarReader reader = new(ms);
-            TarEntry actualEntry = await reader.GetNextEntryAsync();
-            Assert.NotNull(actualEntry);
-            // Gnu header length is 512, data starts in the next position
-            Assert.Equal(512, actualEntry.DataOffset);
+        await using MemoryStream ms = new();
+
+        await using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
+        {
+            // Start with a regular file entry without data
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
+            await writer.WriteEntryAsync(entry);
         }
+        ms.Position = 0;
 
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public void DataOffset_LongPath_LongLink_SecondEntry(bool canSeek)
+        await using (TarReader reader = new(ms, leaveOpen: true))
         {
-            string veryLongPathName = new string('a', 1234); // Forces using a GNU LongPath entry
-            string veryLongLinkName = new string('b', 1234); // Forces using a GNU LongLink entry
+            GnuTarEntry entry = await reader.GetNextEntryAsync() as GnuTarEntry;
+            Assert.NotNull(entry);
+            Assert.Equal(0, entry.Length);
+        }
+        ms.Position = 0;
+        ValidateUnusedBytesInSizeField(ms, 0);
 
-            using MemoryStream ms = new();
-            using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry1 = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongPathName);
-                entry1.LinkName = veryLongLinkName;
-                writer.WriteEntry(entry1);
+        ms.SetLength(0); // Reset the stream
+        byte[] data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; // 8 bytes of data means a size of 10 in octal
+        await using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
+        {
+            // Start with a regular file entry with data
+            GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
+            entry.DataStream = new MemoryStream(data);
+            await writer.WriteEntryAsync(entry);
+        }
 
-                GnuTarEntry entry2 = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongPathName);
-                entry2.LinkName = veryLongLinkName;
-                writer.WriteEntry(entry2);
-            }
-            ms.Position = 0;
-
-            using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
-            using TarReader reader = new(streamToRead);
-            TarEntry firstEntry = reader.GetNextEntry();
-            Assert.NotNull(firstEntry);
-            // GNU first writes the long link and long path entries, containing:
-            // * 512 bytes of the regular long link tar header
-            // * 1234 bytes for the data section containing the full long link
-            // * 302 bytes of padding
-            // * 512 bytes of the regular long path tar header
-            // * 1234 bytes for the data section containing the full long path
-            // * 302 bytes of padding
-            // Then it writes the actual regular file entry, containing:
-            // * 512 bytes of the regular tar header
-            // Totalling 4608.
-            // The regular file data section starts on the next byte.
-            long firstExpectedDataOffset = canSeek ? 4608 : -1;
-            Assert.Equal(firstExpectedDataOffset, firstEntry.DataOffset);
-
-            TarEntry secondEntry = reader.GetNextEntry();
-            Assert.NotNull(secondEntry);
-            // First entry (including its long link and long path entries) end at 4608 (no padding, empty, as symlink has no data)
-            // Second entry (including its long link and long path entries) data section starts one byte after 4608 + 4608 = 9216
-            long secondExpectedDataOffset = canSeek ? 9216 : -1;
-            Assert.Equal(secondExpectedDataOffset, secondEntry.DataOffset);
-        }
-
-        [Theory]
-        [InlineData(false)]
-        [InlineData(true)]
-        public async Task DataOffset_LongPath_LongLink_SecondEntry_Async(bool canSeek)
-        {
-            string veryLongPathName = new string('a', 1234); // Forces using a GNU LongPath entry
-            string veryLongLinkName = new string('b', 1234); // Forces using a GNU LongLink entry
-
-            await using MemoryStream ms = new();
-            await using (TarWriter writer = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry1 = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongPathName);
-                entry1.LinkName = veryLongLinkName;
-                await writer.WriteEntryAsync(entry1);
+        ms.Position = 0;
+        await using (TarReader reader = new(ms, leaveOpen: true))
+        {
+            GnuTarEntry entry = await reader.GetNextEntryAsync() as GnuTarEntry;
+            Assert.NotNull(entry);
+            Assert.Equal(data.Length, entry.Length);
+        }
+        ms.Position = 0;
+        ValidateUnusedBytesInSizeField(ms, data.Length);
+    }
 
-                GnuTarEntry entry2 = new GnuTarEntry(TarEntryType.SymbolicLink, veryLongPathName);
-                entry2.LinkName = veryLongLinkName;
-                await writer.WriteEntryAsync(entry2);
-            }
-            ms.Position = 0;
-
-            await using Stream streamToRead = new WrappedStream(ms, canWrite: true, canRead: true, canSeek: canSeek);
-            await using TarReader reader = new(streamToRead);
-            TarEntry firstEntry = await reader.GetNextEntryAsync();
-            Assert.NotNull(firstEntry);
-            // GNU first writes the long link and long path entries, containing:
-            // * 512 bytes of the regular long link tar header
-            // * 1234 bytes for the data section containing the full long link
-            // * 302 bytes of padding
-            // * 512 bytes of the regular long path tar header
-            // * 1234 bytes for the data section containing the full long path
-            // * 302 bytes of padding
-            // Then it writes the actual regular file entry, containing:
-            // * 512 bytes of the regular tar header
-            // Totalling 4608.
-            // The regular file data section starts on the next byte.
-            long firstExpectedDataOffset = canSeek ? 4608 : -1;
-            Assert.Equal(firstExpectedDataOffset, firstEntry.DataOffset);
-
-            TarEntry secondEntry = await reader.GetNextEntryAsync();
-            Assert.NotNull(secondEntry);
-            // First entry (including its long link and long path entries) end at 4608 (no padding, empty, as symlink has no data)
-            // Second entry (including its long link and long path entries) data section starts one byte after 4608 + 4608 = 9216
-            long secondExpectedDataOffset = canSeek ? 9216 : -1;
-            Assert.Equal(secondExpectedDataOffset, secondEntry.DataOffset);
-        }
-
-        [Fact]
-        public void UnusedBytesInSizeFieldShouldBeZeroChars()
-        {
-            // The GNU format sets the unused bytes in the size field to "0" characters.
-
-            using MemoryStream ms = new();
-
-            using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
-            {
-                // Start with a regular file entry without data
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
-                writer.WriteEntry(entry);
-            }
-            ms.Position = 0;
+    private void ValidateUnusedBytesInSizeField(MemoryStream ms, long size)
+    {
+        // internally, the unused bytes in the size field should be "0" characters,
+        // and the rest should be the octal value of the size field
+
+        // name, mode, uid, gid,
+        // size
+        int sizeStart = 100 + 8 + 8 + 8;
+        byte[] buffer = new byte[12]; // The size field is 12 bytes in length
+
+        ms.Seek(sizeStart, SeekOrigin.Begin);
+        ms.Read(buffer);
+
+        // Convert the base 10 value of size to base 8
+        string octalSize = Convert.ToString(size, 8).PadLeft(11, '0');
+        byte[] octalSizeBytes = Encoding.ASCII.GetBytes(octalSize);
+        // The last byte should be a null character
+        Assert.Equal(octalSizeBytes, buffer.Take(octalSizeBytes.Length).ToArray());
+    }
 
-            using (TarReader reader = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry = reader.GetNextEntry() as GnuTarEntry;
-                Assert.NotNull(entry);
-                Assert.Equal(0, entry.Length);
-            }
-            ms.Position = 0;
-            ValidateUnusedBytesInSizeField(ms, 0);
+    public static IEnumerable<object[]> NameAndLink_TestData()
+    {
+        // Name and link have a max length of 100. Anything longer goes into LongPath or LongLink entries in GNU.
+        yield return new object[] { InitialEntryName, InitialEntryName }; // Short name and short link
+        yield return new object[] { InitialEntryName, new string('b', 101) }; // Short name and long link
+        yield return new object[] { new string('a', 101), InitialEntryName }; // Long name and short link
+        yield return new object[] { new string('a', 101), new string('b', 101) }; // Long name and long link
+    }
 
-            ms.SetLength(0); // Reset the stream
-            byte[] data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; // 8 bytes of data means a size of 10 in octal
-            using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
-            {
-                // Start with a regular file entry with data
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
-                entry.DataStream = new MemoryStream(data);
-                writer.WriteEntry(entry);
-            }
+    private GnuTarEntry CreateEntryForLongLinkLongPathChecks(string name, string linkName)
+    {
+        // A SymbolicLink entry can test both LongLink and LongPath entries if
+        // the length of either string is longer than what fits in the header.
+        return new GnuTarEntry(TarEntryType.SymbolicLink, name)
+        {
+            LinkName = linkName,
+            ModificationTime = DateTimeOffset.UnixEpoch,
+            AccessTime = DateTimeOffset.UnixEpoch,
+            ChangeTime = DateTimeOffset.UnixEpoch,
+            Uid = 0,
+            Gid = 0,
+            Mode = 0,
+            UserName = TestUName,
+            GroupName = TestGName
+        };
+    }
 
-            ms.Position = 0;
-            using (TarReader reader = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry = reader.GetNextEntry() as GnuTarEntry;
-                Assert.NotNull(entry);
-                Assert.Equal(data.Length, entry.Length);
-            }
-            ms.Position = 0;
-            ValidateUnusedBytesInSizeField(ms, data.Length);
+    private void ValidateEntryForRegularEntryInLongLinkAndLongPathChecks(GnuTarEntry entry, string name, string linkName)
+    {
+        Assert.NotNull(entry);
+        Assert.Equal(DateTimeOffset.UnixEpoch, entry.ModificationTime);
+        Assert.Equal(DateTimeOffset.UnixEpoch, entry.AccessTime);
+        Assert.Equal(DateTimeOffset.UnixEpoch, entry.ChangeTime);
+        Assert.Equal(name, entry.Name);
+        Assert.Equal(linkName, entry.LinkName);
+        Assert.Equal(0, entry.Uid); // Should be '0' chars in the long header
+        Assert.Equal(0, entry.Gid); // Should be '0' chars in the long header
+        Assert.Equal(UnixFileMode.None, entry.Mode); // Should be '0' chars in the long header
+        Assert.Equal(TestUName, entry.UserName);
+        Assert.Equal(TestGName, entry.GroupName);
+        Assert.Equal(0, entry.Length); // No data in the main entry
+    }
+
+    [Theory]
+    [MemberData(nameof(NameAndLink_TestData))]
+    public void Check_LongLink_AndLongPath_Metadata(string name, string linkName)
+    {
+        // The GNU format sets the mtime, atime and ctime to nulls in headers when they are set to the unix epoch.
+        // Also the uid and gid should be '0' in the long entries headers.
+        // Also the uname and gname in the long entry headers should be set to those of the main entry.
+
+        using MemoryStream ms = new();
+
+        using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
+        {
+            GnuTarEntry entry = CreateEntryForLongLinkLongPathChecks(name, linkName);
+            writer.WriteEntry(entry);
         }
+        ms.Position = 0;
 
-        [Fact]
-        public async Task UnusedBytesInSizeFieldShouldBeZeroChars_Async()
+        using (TarReader reader = new(ms, leaveOpen: true))
         {
-            // The GNU format sets the unused bytes in the size field to "0" characters.
+            GnuTarEntry entry = reader.GetNextEntry() as GnuTarEntry;
+            ValidateEntryForRegularEntryInLongLinkAndLongPathChecks(entry, name, linkName);
+        }
 
-            await using MemoryStream ms = new();
+        ValidateLongEntryBytes(ms, name, linkName);
+    }
 
-            await using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
-            {
-                // Start with a regular file entry without data
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
-                await writer.WriteEntryAsync(entry);
-            }
-            ms.Position = 0;
+    [Theory]
+    [MemberData(nameof(NameAndLink_TestData))]
+    public async Task Check_LongLink_AndLongPath_Metadata_Async(string name, string linkName)
+    {
+        // The GNU format sets the mtime, atime and ctime to nulls in headers when they are set to the unix epoch.
+        // Also the uid and gid should be '0' in the long entries headers.
+        // Also the uname and gname in the long entry headers should be set to those of the main entry.
 
-            await using (TarReader reader = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry = await reader.GetNextEntryAsync() as GnuTarEntry;
-                Assert.NotNull(entry);
-                Assert.Equal(0, entry.Length);
-            }
-            ms.Position = 0;
-            ValidateUnusedBytesInSizeField(ms, 0);
+        await using MemoryStream ms = new();
 
-            ms.SetLength(0); // Reset the stream
-            byte[] data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; // 8 bytes of data means a size of 10 in octal
-            await using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
-            {
-                // Start with a regular file entry with data
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName);
-                entry.DataStream = new MemoryStream(data);
-                await writer.WriteEntryAsync(entry);
-            }
+        await using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
+        {
+            GnuTarEntry entry = CreateEntryForLongLinkLongPathChecks(name, linkName);
+            await writer.WriteEntryAsync(entry);
+        }
+        ms.Position = 0;
 
-            ms.Position = 0;
-            await using (TarReader reader = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry = await reader.GetNextEntryAsync() as GnuTarEntry;
-                Assert.NotNull(entry);
-                Assert.Equal(data.Length, entry.Length);
-            }
-            ms.Position = 0;
-            ValidateUnusedBytesInSizeField(ms, data.Length);
+        await using (TarReader reader = new(ms, leaveOpen: true))
+        {
+            GnuTarEntry entry = await reader.GetNextEntryAsync() as GnuTarEntry;
+            ValidateEntryForRegularEntryInLongLinkAndLongPathChecks(entry, name, linkName);
         }
 
-        private void ValidateUnusedBytesInSizeField(MemoryStream ms, long size)
+        ValidateLongEntryBytes(ms, name, linkName);
+    }
+
+    private void ValidateLongEntryBytes(MemoryStream ms, string name, string linkName)
+    {
+        bool isLongPath = name.Length >= 100;
+        bool isLongLink = linkName.Length >= 100;
+
+        ms.Position = 0;
+
+        long nextEntryStart = 0;
+        long reportedSize;
+
+        if (isLongLink)
         {
-            // internally, the unused bytes in the size field should be "0" characters,
-            // and the rest should be the octal value of the size field
+            reportedSize = CheckHeaderMetadataAndGetReportedSize(ms, nextEntryStart, isLongLinkOrLongPath: true);
+            CheckDataContainsExpectedString(ms, nextEntryStart + 512, reportedSize, linkName, shouldTrim: false); // Skip to the data section
+            nextEntryStart += 512 + 512; // Skip the current header and the long link entry
+            Assert.True(linkName.Length < 512, "Do not test paths longer than a 512 byte block");
+        }
 
-            // name, mode, uid, gid,
-            // size
-            int sizeStart = 100 + 8 + 8 + 8;
-            byte[] buffer = new byte[12]; // The size field is 12 bytes in length
+        if (isLongPath)
+        {
+            reportedSize = CheckHeaderMetadataAndGetReportedSize(ms, nextEntryStart, isLongLinkOrLongPath: true);
+            CheckDataContainsExpectedString(ms, nextEntryStart + 512, reportedSize, name, shouldTrim: false); // Skip to the data section
+            nextEntryStart += 512 + 512; // Skip the current header and the long path entry
+            Assert.True(name.Length < 512, "Do not test paths longer than a 512 byte block");
+        }
 
-            ms.Seek(sizeStart, SeekOrigin.Begin);
-            ms.Read(buffer);
+        CheckHeaderMetadataAndGetReportedSize(ms, nextEntryStart, isLongLinkOrLongPath: false);
+    }
 
-            // Convert the base 10 value of size to base 8
-            string octalSize = Convert.ToString(size, 8).PadLeft(11, '0');
-            byte[] octalSizeBytes = Encoding.ASCII.GetBytes(octalSize);
-            // The last byte should be a null character
-            Assert.Equal(octalSizeBytes, buffer.Take(octalSizeBytes.Length).ToArray());
+    private long CheckHeaderMetadataAndGetReportedSize(MemoryStream ms, long nextEntryStart, bool isLongLinkOrLongPath)
+    {
+        // internally, mtime, atime and ctime should be nulls
+        // and if the entry is a long path or long link, the entry's data length should be
+        // equal to the string plus a null character
+
+        // name mode uid gid size mtime checksum typeflag linkname magic uname gname devmajor devminor atime ctime
+        // 100  8    8   8   12   12    8        1        100      8     32    32    8        8        12    12
+        long nameStart = nextEntryStart;
+        long modeStart = nameStart + 100;
+        long uidStart = modeStart + 8;
+        long gidStart = uidStart + 8;
+        long sizeStart = gidStart + 8;
+        long mTimeStart = sizeStart + 12;
+        long checksumStart = mTimeStart + 12;
+        long typeflagStart = checksumStart + 8;
+        long linkNameStart = typeflagStart + 1;
+        long magicStart = linkNameStart + 100;
+        long uNameStart = magicStart + 8;
+        long gNameStart = uNameStart + 32;
+        long devMajorStart = gNameStart + 32;
+        long devMinorStart = devMajorStart + 8;
+        long aTimeStart = devMinorStart + 8;
+        long cTimeStart = aTimeStart + 12;
+
+        byte[] buffer = new byte[12]; // size, mtime, atime, ctime all are 12 bytes in length
+
+        if (isLongLinkOrLongPath)
+        {
+            CheckBytesAreZeros(ms, buffer.AsSpan(0, 8), uidStart);
+            CheckBytesAreZeros(ms, buffer.AsSpan(0, 8), gidStart);
+        }
+        else
+        {
+            CheckBytesAreZeros(ms, buffer.AsSpan(0, 8), modeStart);
         }
+        CheckBytesAreZeros(ms, buffer, mTimeStart);
+        CheckBytesAreZeros(ms, buffer, aTimeStart);
+        CheckBytesAreZeros(ms, buffer, cTimeStart);
+        CheckDataContainsExpectedString(ms, uNameStart, 32, TestUName, shouldTrim: true);
+        CheckDataContainsExpectedString(ms, gNameStart, 32, TestGName, shouldTrim: true);
+
+        ms.Seek(sizeStart, SeekOrigin.Begin);
+        ms.Read(buffer);
+        return ParseNumeric<long>(buffer);
+    }
 
-        [Fact]
-        public void ATime_CTime_Epochs_ShouldBeNulls()
+    private void CheckBytesAreSpecificChar(MemoryStream ms, Span<byte> buffer, long dataStart, byte charToCheck)
+    {
+        ms.Seek(dataStart, SeekOrigin.Begin);
+        ms.Read(buffer);
+        foreach (byte b in buffer.Slice(0, buffer.Length - 1)) // The last byte should be a null character
         {
-            // The GNU format sets the access and change times to nulls when they are set to the unix epoch.
+            Assert.Equal(charToCheck, b);
+        }
+        Assert.Equal(0, buffer[^1]); // The last byte should be a null character
+    }
 
-            using MemoryStream ms = new();
+    private void CheckBytesAreNulls(MemoryStream ms, Span<byte> buffer, long dataStart) => CheckBytesAreSpecificChar(ms, buffer, dataStart, 0); // null char
 
-            using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
-            {
-                // Should not be "0" characters, but null characters
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName)
-                {
-                    AccessTime = DateTimeOffset.UnixEpoch,
-                    ChangeTime = DateTimeOffset.UnixEpoch
-                };
-                writer.WriteEntry(entry);
-            }
-            ms.Position = 0;
+    private void CheckBytesAreZeros(MemoryStream ms, Span<byte> buffer, long dataStart) => CheckBytesAreSpecificChar(ms, buffer, dataStart, 0x30); // '0' char
 
-            // Publicly they should be the unix epoch
-            using (TarReader reader = new(ms, leaveOpen: true))
-            {
-                GnuTarEntry entry = reader.GetNextEntry() as GnuTarEntry;
-                Assert.NotNull(entry);
-                Assert.Equal(DateTimeOffset.UnixEpoch, entry.AccessTime);
-                Assert.Equal(DateTimeOffset.UnixEpoch, entry.ChangeTime);
-            }
+    private void CheckDataContainsExpectedString(MemoryStream ms, long dataStart, long actualDataLength, string expectedString, bool shouldTrim)
+    {
+        ms.Seek(dataStart, SeekOrigin.Begin);
+        byte[] buffer = new byte[actualDataLength];
+        ms.Read(buffer);
 
-            ValidateATimeAndCTimeBytes(ms);
+        if (shouldTrim)
+        {
+            string actualString = Encoding.ASCII.GetString(TrimEndingNullsAndSpaces(buffer));
+            Assert.Equal(expectedString, actualString);
+        }
+        else
+        {
+            string actualString = Encoding.ASCII.GetString(buffer);
+            Assert.Equal(expectedString, actualString[..^1]); // The last byte should be a null character
         }
+    }
 
-        [Fact]
-        public async Task ATime_CTime_Epochs_ShouldBeNulls_Async()
+    private static T ParseNumeric<T>(ReadOnlySpan<byte> buffer) where T : struct, INumber<T>, IBinaryInteger<T>
+    {
+        byte leadingByte = buffer[0];
+        if (leadingByte == 0xff)
+        {
+            return T.ReadBigEndian(buffer, isUnsigned: false);
+        }
+        else if (leadingByte == 0x80)
         {
-            await using MemoryStream ms = new();
+            return T.ReadBigEndian(buffer.Slice(1), isUnsigned: true);
+        }
+        else
+        {
+            return ParseOctal<T>(buffer);
+        }
+    }
 
-            await using (TarWriter writer = new(ms, TarEntryFormat.Gnu, leaveOpen: true))
-            {
-                // Should not be "0" characters, but null characters
-                GnuTarEntry entry = new GnuTarEntry(TarEntryType.RegularFile, InitialEntryName)
-                {
-                    AccessTime = DateTimeOffset.UnixEpoch,
-                    ChangeTime = DateTimeOffset.UnixEpoch
-                };
-                await writer.WriteEntryAsync(entry);
-            }
-            ms.Position = 0;
+    private static T ParseOctal<T>(ReadOnlySpan<byte> buffer) where T : struct, INumber<T>
+    {
+        buffer = TrimEndingNullsAndSpaces(buffer);
+        buffer = TrimLeadingNullsAndSpaces(buffer);
 
-            // Publicly they should be the unix epoch
-            await using (TarReader reader = new(ms, leaveOpen: true))
+        if (buffer.Length == 0)
+        {
+            return T.Zero;
+        }
+
+        T octalFactor = T.CreateTruncating(8u);
+        T value = T.Zero;
+        foreach (byte b in buffer)
+        {
+            uint digit = (uint)(b - '0');
+            if (digit >= 8)
             {
-                GnuTarEntry entry = await reader.GetNextEntryAsync() as GnuTarEntry;
-                Assert.NotNull(entry);
-                Assert.Equal(DateTimeOffset.UnixEpoch, entry.AccessTime);
-                Assert.Equal(DateTimeOffset.UnixEpoch, entry.ChangeTime);
+                throw new InvalidDataException(SR.Format(SR.TarInvalidNumber));
             }
 
-            ValidateATimeAndCTimeBytes(ms);
+            value = checked((value * octalFactor) + T.CreateTruncating(digit));
         }
 
-        private void ValidateATimeAndCTimeBytes(MemoryStream ms)
-        {
-            // internally, atime and ctime should be nulls
-
-            // name, mode, uid, gid, size, mtime, checksum, typeflag, linkname, magic, uname, gname, devmajor, devminor,
-            // atime, ctime
-            int aTimeStart = 100 + 8 + 8 + 8 + 12 + 12 + 8 + 1 + 100 + 8 + 32 + 32 + 8 + 8;
-            int cTimeStart = aTimeStart + 12;
-            byte[] buffer = new byte[12]; // atime and ctime are 12 bytes in length
+        return value;
+    }
 
-            ms.Seek(aTimeStart, SeekOrigin.Begin);
-            ms.Read(buffer);
+    private static ReadOnlySpan<byte> TrimEndingNullsAndSpaces(ReadOnlySpan<byte> buffer)
+    {
+        int trimmedLength = buffer.Length;
+        while (trimmedLength > 0 && buffer[trimmedLength - 1] is 0 or 32)
+        {
+            trimmedLength--;
+        }
 
-            Assert.All(buffer, b => Assert.Equal(0, b)); // All should be nulls
+        return buffer.Slice(0, trimmedLength);
+    }
 
-            ms.Seek(cTimeStart, SeekOrigin.Begin);
-            ms.Read(buffer);
-            Assert.All(buffer, b => Assert.Equal(0, b)); // All should be nulls
+    private static ReadOnlySpan<byte> TrimLeadingNullsAndSpaces(ReadOnlySpan<byte> buffer)
+    {
+        int newStart = 0;
+        while (newStart < buffer.Length && buffer[newStart] is 0 or 32)
+        {
+            newStart++;
         }
+
+        return buffer.Slice(newStart);
     }
 }
+}
diff --git a/src/libraries/System.Formats.Tar/tests/TarWriter/TarWriter.Tests.cs b/src/libraries/System.Formats.Tar/tests/TarWriter/TarWriter.Tests.cs
index 23ba1bc4733fd3..1dbd3fc9fdf7bb 100644
--- a/src/libraries/System.Formats.Tar/tests/TarWriter/TarWriter.Tests.cs
+++ b/src/libraries/System.Formats.Tar/tests/TarWriter/TarWriter.Tests.cs
@@ -363,7 +363,7 @@ private int GetChecksumForCommonFields(TarEntry entry, TarEntryType entryType)
             if (entryType is TarEntryType.RegularFile or TarEntryType.V7RegularFile)
             {
                 entry.DataStream = new MemoryStream();
-                byte[] buffer = new byte[] { 72, 101, 108, 108, 111 }; // values don't matter, only length (5)
+                byte[] buffer = [ 72, 101, 108, 108, 111 ]; // values don't matter, only length (5)
 
                 // '0000000005\0' = 48 + 48 + 48 + 48 + 48 + 48 + 48 + 48 + 48 + 48 + 53 + 0 = 533
                 entry.DataStream.Write(buffer);
@@ -377,9 +377,9 @@ private int GetChecksumForCommonFields(TarEntry entry, TarEntryType entryType)
             }
 
             // If V7 regular file:            '\0' = 0
-                // If Ustar/Pax/Gnu regular file: '0'  = 48
-                // If block device:               '4'  = 52
-                expectedChecksum += (byte)entryType;
+            // If Ustar/Pax/Gnu regular file: '0'  = 48
+            // If block device:               '4'  = 52
+            expectedChecksum += (byte)entryType;
 
             // Checksum so far: 256 + 351 + 353 + 359 + 571 = decimal 1890
             // If V7RegularFile: 1890 + 533 + 0  = 2423 (octal 4567) => '004567\0'
@@ -440,7 +440,7 @@ private int GetChecksumForFormatSpecificFields(TarEntry entry, TarEntryFormat fo
 
                     gnuEntry.ChangeTime = expectedTimestampToTest;
                     checksum += expectedTimestampChecksumToTest;
-                    // Total: UnixEpoch = 0, otherwise = 1142
+                    // Total: UnixEpoch = 1056, otherwise = 1142
 
                     void GetTimestampToTest(bool testEpoch, out DateTimeOffset expectedTimestampToTest, out int expectedTimestampChecksumToTest)
                     {
@@ -452,8 +452,8 @@ void GetTimestampToTest(bool testEpoch, out DateTimeOffset expectedTimestampToTe
                             expectedTimestampToTest = TimestampForChecksum; // ToUnixTimeSeconds() = decimal 1641095100, octal 14164217674;
                         }
 
-                        expectedTimestampChecksumToTest = 0;
-                        // '\0\0\0\0\0\0\0\0\0\0\0\0' = 0
+                        expectedTimestampChecksumToTest = 528;
+                        // '00000000000\0' = 0
                         expectedTimestampToTest = UnixEpochTimestampForChecksum; // ToUnixTimeSeconds() = decimal 0, octal 0;
                     }
                 }
@@ -466,7 +466,9 @@ void GetTimestampToTest(bool testEpoch, out DateTimeOffset expectedTimestampToTe
             // Gnu RegularFile: 623 + 1004 + 1142 = 2769
             // Ustar BlockDevice: 655 + 1004 + 686 = 2345
             // Pax BlockDevice: 655 + 1004 + 686 = 2345
-            // Gnu BlockDevice: 623 + 1004 + 686 + 1142 = 3455
+            // Gnu BlockDevice:
+            //    No epoch: 623 + 1004 + 686 + 1142 = 3455
+            //    Epoch: 623 + 1004 + 686 + 1056 = 3369
             return checksum;
         }
     }

From 95fb34415333dc76c1ba886e2043cacc17684127 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Thu, 24 Apr 2025 11:54:34 -0700
Subject: [PATCH 2/5] Run outerloop pipeline only for release branches, not
 staging/preview (#115010)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

I noticed we were sending 30k workitems each day to various Helix queues, this is due to the outerloop pipeline having a schedule triggere which matches old preview branches or the staging branches.

This fixes that and also sets it so that the trigger only applies if there are actual source changes.

Co-authored-by: Alexander Köplinger <alex.koeplinger@outlook.com>
---
 eng/pipelines/libraries/outerloop-mono.yml | 1 +
 eng/pipelines/libraries/outerloop.yml      | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/eng/pipelines/libraries/outerloop-mono.yml b/eng/pipelines/libraries/outerloop-mono.yml
index 329de2ea9267e3..929a02ed080482 100644
--- a/eng/pipelines/libraries/outerloop-mono.yml
+++ b/eng/pipelines/libraries/outerloop-mono.yml
@@ -6,6 +6,7 @@ schedules:
   branches:
     include:
     - main
+  always: false # run only if there were changes since the last successful scheduled run.
 
 variables:
   - template: variables.yml
diff --git a/eng/pipelines/libraries/outerloop.yml b/eng/pipelines/libraries/outerloop.yml
index bbb1adc12cde55..afc38926ea35eb 100644
--- a/eng/pipelines/libraries/outerloop.yml
+++ b/eng/pipelines/libraries/outerloop.yml
@@ -6,7 +6,8 @@ schedules:
   branches:
     include:
     - main
-    - release/*.*
+    - release/*.0
+  always: false # run only if there were changes since the last successful scheduled run.
 
 variables:
   - template: variables.yml

From 1e69c98f8666b6a238206cf95febcd89c97e7f35 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marek=20Fi=C5=A1era?= <mara@neptuo.com>
Date: Thu, 24 Apr 2025 22:23:08 +0200
Subject: [PATCH 3/5] Ensure compression targets run after preloading (#114960)

Customers using WebAssembly preloading (on by default) loses the ability to use pre-compressed asset endpoint for preloaded asset in Blazor Web scenario.
---
 .../build/Microsoft.NET.Sdk.WebAssembly.Browser.targets         | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/mono/nuget/Microsoft.NET.Sdk.WebAssembly.Pack/build/Microsoft.NET.Sdk.WebAssembly.Browser.targets b/src/mono/nuget/Microsoft.NET.Sdk.WebAssembly.Pack/build/Microsoft.NET.Sdk.WebAssembly.Browser.targets
index 3e781a14d8a61b..60a69f64fb3eaf 100644
--- a/src/mono/nuget/Microsoft.NET.Sdk.WebAssembly.Pack/build/Microsoft.NET.Sdk.WebAssembly.Browser.targets
+++ b/src/mono/nuget/Microsoft.NET.Sdk.WebAssembly.Pack/build/Microsoft.NET.Sdk.WebAssembly.Browser.targets
@@ -107,6 +107,7 @@ Copyright (c) .NET Foundation. All rights reserved.
       ResolveWasmOutputs;
       _GenerateBuildWasmBootJson;
       _AddWasmStaticWebAssets;
+      _AddWasmPreloadBuildProperties;
     </ResolveCompressedFilesDependsOn>
     <ResolveCompressedFilesForPublishDependsOn Condition="'$(WasmBuildingForNestedPublish)' != 'true'">
       $(ResolveCompressedFilesForPublishDependsOn);
@@ -114,6 +115,7 @@ Copyright (c) .NET Foundation. All rights reserved.
       ComputeWasmExtensions;
       GeneratePublishWasmBootJson;
       _AddPublishWasmBootJsonToStaticWebAssets;
+      _AddWasmPreloadPublishProperties;
     </ResolveCompressedFilesForPublishDependsOn>
     <CompressFilesForPublishDependsOn Condition="'$(WasmBuildingForNestedPublish)' != 'true'">
       $(CompressFilesForPublishDependsOn);

From 49efa9bf1ea81bc72360e0fd6ffeb4a054b4fee3 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Thu, 24 Apr 2025 15:15:23 -0700
Subject: [PATCH 4/5] [release/10.0-preview4] Rewrite of
 System.Numerics.Tensors to allow for more code sharing, various correctness
 fixes, and stability improvements (#114979)

* Refactor Tensor to be more reusable and validate appropriate state

* Handle Equals, GreaterThan, GreaterThanOrEqual, LessThan, LessThanOrEqual, and the *All/*Any variants

* Many implementations correctly swapped to new form. (#25)

* Refactor Tensor to be more reusable and validate appropriate state

* finishing tensor primitives work

---------

Co-authored-by: Tanner Gooding <tagoo@outlook.com>

* more tensors updates (#26)

* Resolve a few build failures

* Ensure SetSlice and ToString are working as expected

* Tensors lastfew (#27)

* only couple left

* pausing for food

* fixed rented buffer

* squeeze/unsqueeze

* set slice/ split

* only 2 left

* Minor cleanup of the Tensor files

* Ensure that tensor tests are building

* Resolving various build failures due to API compatibility

* Ensure flattendLength is adjusted after the stride is set for that dimension

* Ensure that we set linearLength if -1 is passed in when strides is empty

* Ensure that the first index is correct

* Cleanup to ensure iteration and construction initializes correctly

* Ensure that broadcasting is allowed to be in any stride position

* Have AreCompatible handle empty shapes

* Ensure IndexOutOfRangeException is thrown for invalid indexes

* Ensure that the stride is set to 0 when the length of a dimension is 1, so embedded broadcasting works

* Fixing Broadcasting Loop (#29)

* Fixing Broadcasting Loop

* fixes from pr coments

* squeeze fixed

* unsqueeze

* set slice

* more tensor fies

* Ensure that minimumLinearLength is actually the minimum

* Ensure the rented buffer is cleared

* Fix the AreCompatible checks

* Tensor finishing (#30)

* stack working

* more tensor tests working

* fix factory create tests

* only2 tests left

* Update src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorShape.cs

* Update compatibility suppressions

* transpose working

* reverse working

* Revert the unnecessary sln changes

* Remove an unnecessary using

---------

Co-authored-by: Tanner Gooding <tagoo@outlook.com>
Co-authored-by: Michael Sharp <51342856+michaelgsharp@users.noreply.github.com>
Co-authored-by: Michael Sharp <misharp@microsoft.com>
---
 .../ref/System.Numerics.Tensors.netcore.cs    |  155 +-
 .../src/CompatibilitySuppressions.xml         |  560 ++
 .../src/Resources/Strings.resx                |    9 +-
 .../src/System.Numerics.Tensors.csproj        |   27 +-
 .../src/System/{ => Buffers}/NIndex.cs        |    0
 .../src/System/{ => Buffers}/NRange.cs        |    0
 .../Tensors/netcore/IReadOnlyTensor.cs        |  183 +-
 .../Tensors/netcore/IReadOnlyTensor_1.cs      |  103 +
 .../Numerics/Tensors/netcore/ITensor.cs       |  162 +-
 .../Numerics/Tensors/netcore/ITensor_1.cs     |   93 +
 .../Tensors/netcore/ReadOnlyTensorSpan.cs     |  828 --
 .../Tensors/netcore/ReadOnlyTensorSpan_1.cs   |  524 ++
 .../Tensors/netcore/Tensor.Factory.cs         |  216 -
 .../System/Numerics/Tensors/netcore/Tensor.cs | 5907 ++++++++++++--
 .../Tensors/netcore/TensorExtensions.cs       | 7183 -----------------
 .../Numerics/Tensors/netcore/TensorHelpers.cs |  124 -
 .../Tensors/netcore/TensorOperation.cs        | 2615 ++++++
 .../Numerics/Tensors/netcore/TensorShape.cs   | 1255 ++-
 .../Numerics/Tensors/netcore/TensorSpan.cs    |  933 +--
 .../Tensors/netcore/TensorSpanHelpers.T.cs    |   53 -
 .../Tensors/netcore/TensorSpanHelpers.cs      |  306 -
 .../Numerics/Tensors/netcore/Tensor_1.cs      |  451 ++
 .../src/System/ThrowHelper.cs                 |   43 +-
 .../tests/ReadOnlyTensorSpanTests.cs          |  176 +-
 .../tests/TensorSpanTests.cs                  |  560 +-
 .../tests/TensorTests.cs                      |  601 +-
 26 files changed, 12027 insertions(+), 11040 deletions(-)
 rename src/libraries/System.Numerics.Tensors/src/System/{ => Buffers}/NIndex.cs (100%)
 rename src/libraries/System.Numerics.Tensors/src/System/{ => Buffers}/NRange.cs (100%)
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor_1.cs
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor_1.cs
 delete mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan_1.cs
 delete mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs
 delete mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs
 delete mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorHelpers.cs
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
 delete mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.T.cs
 delete mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.cs
 create mode 100644 src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor_1.cs

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 41a1c32987c353..241a65c5da5067 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
@@ -78,15 +78,15 @@ public partial interface IReadOnlyTensor<TSelf, T> : System.Collections.Generic.
         TSelf this[params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get; }
         new T this[params scoped System.ReadOnlySpan<nint> indexes] { get; }
         System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan();
-        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);
+        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndexes);
+        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges);
+        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<nint> startIndexes);
         void CopyTo(scoped System.Numerics.Tensors.TensorSpan<T> destination);
         void FlattenTo(scoped System.Span<T> destination);
         ref readonly T GetPinnableReference();
-        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);
+        TSelf Slice(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndexes);
+        TSelf Slice(params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges);
+        TSelf Slice(params scoped System.ReadOnlySpan<nint> startIndexes);
         bool TryCopyTo(scoped System.Numerics.Tensors.TensorSpan<T> destination);
         bool TryFlattenTo(scoped System.Span<T> destination);
     }
@@ -106,9 +106,9 @@ public partial interface ITensor<TSelf, T> : System.Collections.Generic.IEnumera
         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(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);
+        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndexes);
+        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges);
+        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<nint> startIndexes);
         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);
         static abstract TSelf CreateUninitialized(scoped System.ReadOnlySpan<nint> lengths, bool pinned = false);
@@ -122,16 +122,19 @@ public readonly ref partial struct ReadOnlyTensorSpan<T>
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
         public ReadOnlyTensorSpan(System.Array? array) { throw null; }
-        public ReadOnlyTensorSpan(System.Array? array, scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public ReadOnlyTensorSpan(System.Array? array, scoped System.ReadOnlySpan<int> start, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public ReadOnlyTensorSpan(System.ReadOnlySpan<T> span) { throw null; }
+        public ReadOnlyTensorSpan(System.ReadOnlySpan<T> span, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
         public ReadOnlyTensorSpan(System.ReadOnlySpan<T> span, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public unsafe ReadOnlyTensorSpan(T* data, nint dataLength) { throw null; }
         [System.CLSCompliantAttribute(false)]
+        public unsafe ReadOnlyTensorSpan(T* data, nint dataLength, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
+        [System.CLSCompliantAttribute(false)]
         public unsafe ReadOnlyTensorSpan(T* data, nint dataLength, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public ReadOnlyTensorSpan(T[]? array) { throw null; }
-        public ReadOnlyTensorSpan(T[]? array, System.Index startIndex, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
+        public ReadOnlyTensorSpan(T[]? array, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
+        public ReadOnlyTensorSpan(T[]? array, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
         public ReadOnlyTensorSpan(T[]? array, int start, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public static System.Numerics.Tensors.ReadOnlyTensorSpan<T> Empty { get { throw null; } }
         public nint FlattenedLength { get { throw null; } }
@@ -162,18 +165,23 @@ 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(params scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndexes) { throw null; }
         public System.Numerics.Tensors.ReadOnlyTensorSpan<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> Slice(params scoped System.ReadOnlySpan<nint> startIndexes) { 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; }
         public void FlattenTo(scoped System.Span<T> destination) { throw null; }
-        public ref partial struct Enumerator
+        public ref partial struct Enumerator : System.Collections.Generic.IEnumerator<T>
         {
             private object _dummy;
             private int _dummyPrimitive;
-            public ref readonly T Current { get { throw null; } }
+            public readonly ref readonly T Current { get { throw null; } }
             public bool MoveNext() { throw null; }
+            public void Reset() { throw null; }
+            void System.IDisposable.Dispose() { throw null; }
+            readonly object? System.Collections.IEnumerator.Current { get { throw null; } }
+            readonly T System.Collections.Generic.IEnumerator<T>.Current { get { throw null; } }
         }
     }
     [System.Diagnostics.CodeAnalysis.Experimental("SYSLIB5001", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
@@ -197,8 +205,14 @@ public static partial class Tensor
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> AsinPi<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Asin<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Asin<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan<T>(this T[]? array, params scoped System.ReadOnlySpan<nint> lengths) { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> AsTensorSpan<T>(this T[]? array, params scoped System.ReadOnlySpan<nint> lengths) { throw null; }
+        public static System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan<T>(this T[]? array) { throw null; }
+        public static System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan<T>(this T[]? array, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
+        public static System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan<T>(this T[]? array, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
+        public static System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan<T>(this T[]? array, int start, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AsTensorSpan<T>(this T[]? array) { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AsTensorSpan<T>(this T[]? array, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AsTensorSpan<T>(this T[]? array, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> AsTensorSpan<T>(this T[]? array, int start, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Atan2Pi<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y) where T : System.Numerics.IFloatingPointIeee754<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Atan2Pi<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Atan2Pi<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, T y) where T : System.Numerics.IFloatingPointIeee754<T> { throw null; }
@@ -251,24 +265,26 @@ public static void BroadcastTo<T>(this System.Numerics.Tensors.Tensor<T> source,
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> CopySign<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, T sign, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.INumber<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Cosh<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IHyperbolicFunctions<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Cosh<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IHyperbolicFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CosineSimilarity<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y) where T : System.Numerics.IRootFunctions<T> { throw null; }
-        public static ref readonly System.Numerics.Tensors.TensorSpan<T> CosineSimilarity<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IRootFunctions<T> { throw null; }
+        public static T CosineSimilarity<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y) where T : System.Numerics.IRootFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> CosPi<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> CosPi<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Cos<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Cos<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateAndFillGaussianNormalDistribution<T>(System.Random random, params scoped System.ReadOnlySpan<nint> lengths) where T : System.Numerics.IFloatingPoint<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateAndFillGaussianNormalDistribution<T>(params scoped System.ReadOnlySpan<nint> lengths) where T : System.Numerics.IFloatingPoint<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateAndFillUniformDistribution<T>(System.Random random, params scoped System.ReadOnlySpan<nint> lengths) where T : System.Numerics.IFloatingPoint<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateAndFillUniformDistribution<T>(params scoped System.ReadOnlySpan<nint> lengths) where T : System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CreateAndFillGaussianNormalDistribution<T>(System.Random random, scoped System.ReadOnlySpan<nint> lengths) where T : System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CreateAndFillGaussianNormalDistribution<T>(scoped System.ReadOnlySpan<nint> lengths) where T : System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CreateAndFillUniformDistribution<T>(System.Random random, scoped System.ReadOnlySpan<nint> lengths) where T : System.Numerics.IFloatingPoint<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CreateAndFillUniformDistribution<T>(scoped System.ReadOnlySpan<nint> lengths) where T : System.Numerics.IFloatingPoint<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> CreateUninitialized<T>(scoped System.ReadOnlySpan<nint> lengths, bool pinned = false) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> CreateUninitialized<T>(scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned = false) { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Create<T>(System.Collections.Generic.IEnumerable<T> values, scoped System.ReadOnlySpan<nint> lengths, bool pinned = false) { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Create<T>(System.Collections.Generic.IEnumerable<T> values, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned = false) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Create<T>(System.Collections.Generic.IEnumerable<T> enumerable, bool pinned = false) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Create<T>(System.Collections.Generic.IEnumerable<T> enumerable, scoped System.ReadOnlySpan<nint> lengths, bool pinned = false) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Create<T>(System.Collections.Generic.IEnumerable<T> enumerable, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned = false) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Create<T>(scoped System.ReadOnlySpan<nint> lengths, bool pinned = false) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Create<T>(scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned = false) { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Create<T>(T[] values, scoped System.ReadOnlySpan<nint> lengths, bool pinned = false) { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Create<T>(T[] values, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides, bool pinned = false) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Create<T>(T[] array) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Create<T>(T[] array, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Create<T>(T[] array, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Create<T>(T[] array, int start, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> DegreesToRadians<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> DegreesToRadians<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static T Distance<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y) where T : System.Numerics.IRootFunctions<T> { throw null; }
@@ -305,7 +321,6 @@ public static void BroadcastTo<T>(this System.Numerics.Tensors.Tensor<T> source,
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> FilteredUpdate<T>(this in System.Numerics.Tensors.TensorSpan<T> tensor, scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<bool> filter, T value) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Floor<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IFloatingPoint<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Floor<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IFloatingPoint<T> { throw null; }
-        public static nint[] GetSmallestBroadcastableLengths(System.ReadOnlySpan<nint> shape1, System.ReadOnlySpan<nint> shape2) { throw null; }
         public static bool GreaterThanAll<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y) where T : System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
         public static bool GreaterThanAll<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, T y) where T : System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
         public static bool GreaterThanAll<T>(T x, in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y) where T : System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
@@ -340,10 +355,10 @@ public static void BroadcastTo<T>(this System.Numerics.Tensors.Tensor<T> source,
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Ieee754Remainder<T>(T x, scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IFloatingPointIeee754<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<int> ILogB<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IFloatingPointIeee754<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<int> ILogB<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<int> destination) where T : System.Numerics.IFloatingPointIeee754<T> { throw null; }
-        public static int IndexOfMaxMagnitude<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
-        public static int IndexOfMax<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
-        public static int IndexOfMinMagnitude<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
-        public static int IndexOfMin<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
+        public static nint IndexOfMaxMagnitude<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
+        public static nint IndexOfMax<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
+        public static nint IndexOfMinMagnitude<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
+        public static nint IndexOfMin<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.INumber<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> LeadingZeroCount<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IBinaryInteger<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> LeadingZeroCount<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IBinaryInteger<T> { throw null; }
         public static bool LessThanAll<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y) where T : System.Numerics.IComparisonOperators<T, T, bool> { throw null; }
@@ -435,7 +450,7 @@ public static void BroadcastTo<T>(this System.Numerics.Tensors.Tensor<T> source,
         public static T Norm<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IRootFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> OnesComplement<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> OnesComplement<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IBitwiseOperators<T, T, T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> PermuteDimensions<T>(this System.Numerics.Tensors.Tensor<T> tensor, params scoped System.ReadOnlySpan<int> dimensions) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> PermuteDimensions<T>(this System.Numerics.Tensors.Tensor<T> tensor, scoped System.ReadOnlySpan<int> dimensions) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> PopCount<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IBinaryInteger<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> PopCount<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IBinaryInteger<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Pow<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.ReadOnlyTensorSpan<T> y) where T : System.Numerics.IPowerFunctions<T> { throw null; }
@@ -449,9 +464,9 @@ public static void BroadcastTo<T>(this System.Numerics.Tensors.Tensor<T> source,
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> RadiansToDegrees<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Reciprocal<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IFloatingPoint<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Reciprocal<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IFloatingPoint<T> { throw null; }
-        public static System.Numerics.Tensors.ReadOnlyTensorSpan<T> Reshape<T>(this in System.Numerics.Tensors.ReadOnlyTensorSpan<T> tensor, params scoped System.ReadOnlySpan<nint> lengths) { throw null; }
-        public static System.Numerics.Tensors.TensorSpan<T> Reshape<T>(this in System.Numerics.Tensors.TensorSpan<T> tensor, params scoped System.ReadOnlySpan<nint> lengths) { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Reshape<T>(this System.Numerics.Tensors.Tensor<T> tensor, params scoped System.ReadOnlySpan<nint> lengths) { throw null; }
+        public static System.Numerics.Tensors.ReadOnlyTensorSpan<T> Reshape<T>(this in System.Numerics.Tensors.ReadOnlyTensorSpan<T> tensor, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
+        public static System.Numerics.Tensors.TensorSpan<T> Reshape<T>(this in System.Numerics.Tensors.TensorSpan<T> tensor, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Reshape<T>(this System.Numerics.Tensors.Tensor<T> tensor, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
         public static void ResizeTo<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> tensor, in System.Numerics.Tensors.TensorSpan<T> destination) { }
         public static void ResizeTo<T>(scoped in System.Numerics.Tensors.TensorSpan<T> tensor, in System.Numerics.Tensors.TensorSpan<T> destination) { }
         public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tensor, in System.Numerics.Tensors.TensorSpan<T> destination) { }
@@ -515,9 +530,9 @@ public static void ResizeTo<T>(scoped in System.Numerics.Tensors.Tensor<T> tenso
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> TanPi<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Tan<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> Tan<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.ITrigonometricFunctions<T> { throw null; }
-        public static string ToString<T>(this in System.Numerics.Tensors.ReadOnlyTensorSpan<T> tensor, params scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
-        public static string ToString<T>(this in System.Numerics.Tensors.TensorSpan<T> tensor, params scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
-        public static string ToString<T>(this System.Numerics.Tensors.Tensor<T> tensor, params scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
+        public static string ToString<T>(this in System.Numerics.Tensors.ReadOnlyTensorSpan<T> tensor, scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
+        public static string ToString<T>(this in System.Numerics.Tensors.TensorSpan<T> tensor, scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
+        public static string ToString<T>(this System.Numerics.Tensors.Tensor<T> tensor, scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> TrailingZeroCount<T>(in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x) where T : System.Numerics.IBinaryInteger<T> { throw null; }
         public static ref readonly System.Numerics.Tensors.TensorSpan<T> TrailingZeroCount<T>(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan<T> x, in System.Numerics.Tensors.TensorSpan<T> destination) where T : System.Numerics.IBinaryInteger<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Transpose<T>(System.Numerics.Tensors.Tensor<T> tensor) { throw null; }
@@ -774,16 +789,19 @@ public readonly ref partial struct TensorSpan<T>
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
         public TensorSpan(System.Array? array) { throw null; }
-        public TensorSpan(System.Array? array, scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public TensorSpan(System.Array? array, scoped System.ReadOnlySpan<int> start, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public TensorSpan(System.Span<T> span) { throw null; }
+        public TensorSpan(System.Span<T> span, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
         public TensorSpan(System.Span<T> span, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public unsafe TensorSpan(T* data, nint dataLength) { throw null; }
         [System.CLSCompliantAttribute(false)]
+        public unsafe TensorSpan(T* data, nint dataLength, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
+        [System.CLSCompliantAttribute(false)]
         public unsafe TensorSpan(T* data, nint dataLength, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public TensorSpan(T[]? array) { throw null; }
-        public TensorSpan(T[]? array, System.Index startIndex, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
+        public TensorSpan(T[]? array, scoped System.ReadOnlySpan<nint> lengths) { throw null; }
+        public TensorSpan(T[]? array, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public TensorSpan(T[]? array, int start, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public static System.Numerics.Tensors.TensorSpan<T> Empty { get { throw null; } }
         public nint FlattenedLength { get { throw null; } }
@@ -796,6 +814,10 @@ public readonly ref partial struct TensorSpan<T>
         public int Rank { get { throw null; } }
         [System.Diagnostics.CodeAnalysis.UnscopedRefAttribute]
         public System.ReadOnlySpan<nint> Strides { get { throw null; } }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan() { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndexes) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<nint> startIndexes) { throw null; }
         public void Clear() { }
         public void CopyTo(scoped System.Numerics.Tensors.TensorSpan<T> destination) { }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
@@ -814,20 +836,25 @@ public void FlattenTo(scoped System.Span<T> destination) { }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
         public ref T GetPinnableReference() { throw null; }
         public static bool operator ==(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) { throw null; }
-        public static implicit operator System.Numerics.Tensors.ReadOnlyTensorSpan<T> (System.Numerics.Tensors.TensorSpan<T> span) { throw null; }
+        public static implicit operator System.Numerics.Tensors.ReadOnlyTensorSpan<T> (System.Numerics.Tensors.TensorSpan<T> tensor) { 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(params scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndexes) { throw null; }
         public System.Numerics.Tensors.TensorSpan<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> Slice(params scoped System.ReadOnlySpan<nint> startIndexes) { 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; }
-        public ref partial struct Enumerator
+        public ref partial struct Enumerator : System.Collections.Generic.IEnumerator<T>
         {
             private object _dummy;
             private int _dummyPrimitive;
-            public ref T Current { get { throw null; } }
+            public readonly ref T Current { get { throw null; } }
             public bool MoveNext() { throw null; }
+            public void Reset() { throw null; }
+            void System.IDisposable.Dispose() { throw null; }
+            readonly object? System.Collections.IEnumerator.Current { get { throw null; } }
+            readonly T System.Collections.Generic.IEnumerator<T>.Current { get { throw null; } }
         }
     }
     [System.Diagnostics.CodeAnalysis.ExperimentalAttribute("SYSLIB5001", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
@@ -838,7 +865,6 @@ internal Tensor() { }
         public nint FlattenedLength { get { throw null; } }
         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[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; } }
@@ -858,39 +884,50 @@ internal Tensor() { }
         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(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.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndexes) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped System.ReadOnlySpan<nint> startIndexes) { throw null; }
         public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan() { 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 System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndexes) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(params scoped System.ReadOnlySpan<nint> startIndexes) { throw null; }
         public void Clear() { }
         public void CopyTo(scoped System.Numerics.Tensors.TensorSpan<T> destination) { }
-        public void Fill(object value) { }
         public void Fill(T value) { }
         public void FlattenTo(scoped System.Span<T> destination) { }
-        public System.Collections.Generic.IEnumerator<T> GetEnumerator() { throw null; }
+        public Enumerator GetEnumerator() { throw null; }
         public override int GetHashCode() { throw null; }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
         public ref T GetPinnableReference() { throw null; }
         public System.Buffers.MemoryHandle GetPinnedHandle() { 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 static implicit operator System.Numerics.Tensors.ReadOnlyTensorSpan<T> (System.Numerics.Tensors.Tensor<T> tensor) { throw null; }
+        public static implicit operator System.Numerics.Tensors.TensorSpan<T> (System.Numerics.Tensors.Tensor<T> tensor) { 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; }
+        public System.Numerics.Tensors.Tensor<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndexes) { throw null; }
+        public System.Numerics.Tensors.Tensor<T> Slice(params scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public System.Numerics.Tensors.Tensor<T> Slice(params scoped System.ReadOnlySpan<nint> startIndexes) { throw null; }
         System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
         [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.ITensor.Fill(object value) { }
         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(params scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
+        public string ToString(scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
         public bool TryCopyTo(scoped System.Numerics.Tensors.TensorSpan<T> destination) { throw null; }
         public bool TryFlattenTo(scoped System.Span<T> destination) { throw null; }
+        public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>
+        {
+            private object _dummy;
+            private int _dummyPrimitive;
+            public readonly ref T Current { get { throw null; } }
+            public bool MoveNext() { throw null; }
+            public void Reset() { throw null; }
+            void System.IDisposable.Dispose() { throw null; }
+            readonly object? System.Collections.IEnumerator.Current { get { throw null; } }
+            readonly T System.Collections.Generic.IEnumerator<T>.Current { get { throw null; } }
+        }
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml b/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml
index 06a5854b5aba3c..9fda67ddf4a768 100644
--- a/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml
+++ b/src/libraries/System.Numerics.Tensors/src/CompatibilitySuppressions.xml
@@ -127,6 +127,300 @@
     <Right>lib/netstandard2.0/System.Numerics.Tensors.dll</Right>
     <IsBaselineSuppression>true</IsBaselineSuppression>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ReadOnlyTensorSpan`1.#ctor(`0[],System.Index,System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr})</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ReadOnlyTensorSpan`1.#ctor(System.Array,System.ReadOnlySpan{System.Buffers.NIndex},System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr})</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.CosineSimilarity``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,System.Numerics.Tensors.TensorSpan{``0}@)</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.CosineSimilarity``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.Create``1(``0[],System.ReadOnlySpan{System.IntPtr},System.Boolean)</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.Create``1(``0[],System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr},System.Boolean)</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.GetSmallestBroadcastableLengths(System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr})</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.IndexOfMax``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.IndexOfMaxMagnitude``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.IndexOfMin``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.IndexOfMinMagnitude``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.get_Item(System.Numerics.Tensors.Tensor{System.Boolean})</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.GetEnumerator</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.TensorSpan`1.#ctor(`0[],System.Index,System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr})</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.TensorSpan`1.#ctor(System.Array,System.ReadOnlySpan{System.Buffers.NIndex},System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr})</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ReadOnlyTensorSpan`1.#ctor(`0[],System.Index,System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr})</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ReadOnlyTensorSpan`1.#ctor(System.Array,System.ReadOnlySpan{System.Buffers.NIndex},System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr})</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.CosineSimilarity``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,System.Numerics.Tensors.TensorSpan{``0}@)</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.CosineSimilarity``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.Create``1(``0[],System.ReadOnlySpan{System.IntPtr},System.Boolean)</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.Create``1(``0[],System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr},System.Boolean)</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.GetSmallestBroadcastableLengths(System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr})</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.IndexOfMax``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.IndexOfMaxMagnitude``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.IndexOfMin``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.IndexOfMinMagnitude``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.get_Item(System.Numerics.Tensors.Tensor{System.Boolean})</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.GetEnumerator</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.TensorSpan`1.#ctor(`0[],System.Index,System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr})</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.TensorSpan`1.#ctor(System.Array,System.ReadOnlySpan{System.Buffers.NIndex},System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr})</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.Slice(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.Slice(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.Slice(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ITensor`2.AsTensorSpan(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ITensor`2.AsTensorSpan(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ITensor`2.AsTensorSpan(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ReadOnlyTensorSpan`1.Slice(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.Create``1(System.Collections.Generic.IEnumerable{``0},System.ReadOnlySpan{System.IntPtr},System.Boolean)$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.Create``1(System.Collections.Generic.IEnumerable{``0},System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr},System.Boolean)$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0017</DiagnosticId>
     <Target>M:System.Numerics.Tensors.Tensor.GreaterThanOrEqualAll``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,``0)$0</Target>
@@ -190,6 +484,181 @@
     <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
     <IsBaselineSuppression>true</IsBaselineSuppression>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsTensorSpan(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsTensorSpan(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsTensorSpan(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.op_Implicit(System.Numerics.Tensors.Tensor{`0})~System.Numerics.Tensors.ReadOnlyTensorSpan{`0}$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.op_Implicit(System.Numerics.Tensors.Tensor{`0})~System.Numerics.Tensors.TensorSpan{`0}$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.Slice(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.Slice(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.Slice(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.TensorSpan`1.op_Implicit(System.Numerics.Tensors.TensorSpan{`0})~System.Numerics.Tensors.ReadOnlyTensorSpan{`0}$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.TensorSpan`1.Slice(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net8.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net8.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.Slice(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.Slice(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.IReadOnlyTensor`2.Slice(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ITensor`2.AsTensorSpan(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ITensor`2.AsTensorSpan(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ITensor`2.AsTensorSpan(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.ReadOnlyTensorSpan`1.Slice(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.Create``1(System.Collections.Generic.IEnumerable{``0},System.ReadOnlySpan{System.IntPtr},System.Boolean)$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor.Create``1(System.Collections.Generic.IEnumerable{``0},System.ReadOnlySpan{System.IntPtr},System.ReadOnlySpan{System.IntPtr},System.Boolean)$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0017</DiagnosticId>
     <Target>M:System.Numerics.Tensors.Tensor.GreaterThanOrEqualAll``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@,``0)$0</Target>
@@ -253,6 +722,97 @@
     <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
     <IsBaselineSuppression>true</IsBaselineSuppression>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsReadOnlyTensorSpan(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsTensorSpan(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsTensorSpan(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.AsTensorSpan(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.op_Implicit(System.Numerics.Tensors.Tensor{`0})~System.Numerics.Tensors.ReadOnlyTensorSpan{`0}$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.op_Implicit(System.Numerics.Tensors.Tensor{`0})~System.Numerics.Tensors.TensorSpan{`0}$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.Slice(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.Slice(System.ReadOnlySpan{System.Buffers.NRange})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.Tensor`1.Slice(System.ReadOnlySpan{System.IntPtr})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.TensorSpan`1.op_Implicit(System.Numerics.Tensors.TensorSpan{`0})~System.Numerics.Tensors.ReadOnlyTensorSpan{`0}$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0017</DiagnosticId>
+    <Target>M:System.Numerics.Tensors.TensorSpan`1.Slice(System.ReadOnlySpan{System.Buffers.NIndex})$0</Target>
+    <Left>lib/net9.0/System.Numerics.Tensors.dll</Left>
+    <Right>lib/net9.0/System.Numerics.Tensors.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0021</DiagnosticId>
     <Target>M:System.Numerics.Tensors.Tensor.Average``1(System.Numerics.Tensors.ReadOnlyTensorSpan{``0}@)``0:T:System.Numerics.INumberBase{``0}</Target>
diff --git a/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx b/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
index 1039f4e0e286f0..208b9802175091 100644
--- a/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
+++ b/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx
@@ -201,8 +201,8 @@
   <data name="ThrowArgument_SetSliceNoRange" xml:space="preserve">
     <value>When no ranges are specified the values tensor must be equal in size as the input tensor.</value>
   </data>
-  <data name="ThrowArgument_LengthsNotBroadcastCompatible" xml:space="preserve">
-    <value>Lengths are not broadcast compatible.</value>
+  <data name="ThrowArgument_LengthsNotCompatible" xml:space="preserve">
+    <value>Lengths are not compatible with each other.</value>
   </data>
   <data name="ThrowArgument_SplitNotSplitEvenly" xml:space="preserve">
     <value>The number of splits must perfectly divide the dimension.</value>
@@ -240,4 +240,7 @@
   <data name="Arithmetic_NaN" xml:space="preserve">
     <value>Function does not accept floating point Not-a-Number values.</value>
   </data>
-</root>
+  <data name="ThrowArgument_LengthIsNonZeroForNullReference" xml:space="preserve">
+    <value>The provided length is non zero while the data reference is null.</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 807aaf15ff873d..7202c69d6ab762 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -19,20 +19,8 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
-    <Compile Include="System\Numerics\Tensors\netcore\TensorShape.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\ReadOnlyTensorSpan.cs" />
-    <Compile Include="System\Numerics\Tensors\netcore\TensorSpanHelpers.cs" />
-    <Compile Include="System\Numerics\Tensors\netcore\TensorSpanHelpers.T.cs" />
-    <Compile Include="System\Numerics\Tensors\netcore\TensorSpan.cs" />
-    <Compile Include="System\NIndex.cs" />
-    <Compile Include="System\NRange.cs" />
+    <Compile Include="System\Buffers\NIndex.cs" />
+    <Compile Include="System\Buffers\NRange.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Common\TensorPrimitives.IAggregationOperator.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Common\TensorPrimitives.IBinaryOperator.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Common\TensorPrimitives.IBooleanUnaryOperator.cs" />
@@ -44,6 +32,14 @@
     <Compile Include="System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryOneToFourOperator.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryOperator.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Common\TensorPrimitives.IUnaryTwoToOneOperator.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\IReadOnlyTensor.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\IReadOnlyTensor_1.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\ITensor.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\ITensor_1.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\ReadOnlyTensorSpan_1.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\Tensor_1.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorOperation.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Abs.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Acos.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Acosh.cs" />
@@ -170,6 +166,9 @@
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.TrailingZeroCount.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Truncate.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorPrimitives.Xor.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorShape.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorSpan.cs" />
+    <Compile Include="System\Numerics\Tensors\netcore\TensorSpanDebugView.cs" />
   </ItemGroup>
 
   <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net9.0'))">
diff --git a/src/libraries/System.Numerics.Tensors/src/System/NIndex.cs b/src/libraries/System.Numerics.Tensors/src/System/Buffers/NIndex.cs
similarity index 100%
rename from src/libraries/System.Numerics.Tensors/src/System/NIndex.cs
rename to src/libraries/System.Numerics.Tensors/src/System/Buffers/NIndex.cs
diff --git a/src/libraries/System.Numerics.Tensors/src/System/NRange.cs b/src/libraries/System.Numerics.Tensors/src/System/Buffers/NRange.cs
similarity index 100%
rename from src/libraries/System.Numerics.Tensors/src/System/NRange.cs
rename to src/libraries/System.Numerics.Tensors/src/System/Buffers/NRange.cs
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs
index ce52ab8c279b91..9a90a17cb1640c 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs
@@ -2,181 +2,50 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Buffers;
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
 namespace System.Numerics.Tensors
 {
-
-    /// <summary>
-    /// Represents a read-only tensor.
-    /// </summary>
+    /// <summary>Represents a read-only tensor.</summary>
     [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
     public interface IReadOnlyTensor
     {
-        /// <summary>
-        /// Gets a value that indicates whether the collection is currently empty.
-        /// </summary>
+        /// <summary>Gets the specified element of the tensor.</summary>
+        /// <param name="indexes">The index of the element for which to get.</param>
+        /// <returns>The element that exists at <paramref name="indexes" />.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   Thrown when one of the following conditions is met:
+        ///   * <paramref name="indexes" /> does not contain <see cref="Rank" /> elements
+        ///   * <paramref name="indexes" /> contains an element that is negative or greater than or equal to the corresponding dimension length
+        /// </exception>
+        object? this[params scoped ReadOnlySpan<nint> indexes] { get; }
+
+        /// <inheritdoc cref="this[ReadOnlySpan{nint}]" />
+        object? this[params scoped ReadOnlySpan<NIndex> indexes] { get; }
+
+        /// <summary>Gets the total number of items in the tensor.</summary>
+        nint FlattenedLength { get; }
+
+        /// <summary>Gets a value indicating whether this tensor is empty.</summary>
+        /// <value><see langword="true"/> if this tensor is empty; otherwise, <see langword="false"/>.</value>
         bool IsEmpty { get; }
 
-        /// <summary>
-        /// Gets a value that indicates whether the underlying buffer is pinned.
-        /// </summary>
+        /// <summary>Gets a value that indicates whether the underlying buffer is pinned.</summary>
         bool IsPinned { get; }
 
-        /// <summary>
-        /// Gets the number of elements in the tensor.
-        /// </summary>
-        nint FlattenedLength { get; }
-
-        /// <summary>
-        /// Gets the number of dimensions in the tensor.
-        /// </summary>
-        int Rank { get; }
-
-        /// <summary>
-        /// Gets the length of each dimension in the tensor.
-        /// </summary>
+        /// <summary>Gets the length of each dimension in the tensor.</summary>
         [UnscopedRef]
         ReadOnlySpan<nint> Lengths { get; }
 
-        /// <summary>
-        /// Gets the stride of each dimension in the tensor.
-        /// </summary>
+        /// <summary>Gets the rank, or number of dimensions, in the tensor.</summary>
+        int Rank { get; }
+
+        /// <summary>Gets the stride of each dimension in the tensor.</summary>
         [UnscopedRef]
         ReadOnlySpan<nint> Strides { get; }
 
-        /// <summary>
-        /// Gets the value at the specified indexes.
-        /// </summary>
-        /// <param name="indexes">The indexes to be used.</param>
-        object this[params scoped ReadOnlySpan<nint> indexes] { get; }
-
-        /// <summary>
-        /// Gets the value at the specified indexes.
-        /// </summary>
-        /// <param name="indexes">The indexes to be used.</param>
-        object this[params scoped ReadOnlySpan<NIndex> indexes] { get; }
-
-        /// <summary>
-        /// Pins and gets a <see cref="MemoryHandle"/> to the backing memory.
-        /// </summary>
+        /// <summary>Pins and gets a <see cref="MemoryHandle"/> to the backing memory.</summary>
         /// <returns><see cref="MemoryHandle"/></returns>
         MemoryHandle GetPinnedHandle();
     }
-
-    /// <summary>
-    /// Represents a read-only tensor.
-    /// </summary>
-    /// <typeparam name="TSelf">The type that implements this interface.</typeparam>
-    /// <typeparam name="T">The element type.</typeparam>
-    [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
-    public interface IReadOnlyTensor<TSelf, T> : IReadOnlyTensor, IEnumerable<T>
-        where TSelf : IReadOnlyTensor<TSelf, T>
-    {
-        /// <summary>
-        /// Gets an empty tensor.
-        /// </summary>
-        static abstract TSelf? Empty { get; }
-
-        /// <summary>
-        /// Gets the value at the specified indexes.
-        /// </summary>
-        /// <param name="indexes">The indexes to be used.</param>
-        new T this[params scoped ReadOnlySpan<nint> indexes] { get; }
-
-        /// <summary>
-        /// Gets the value at the specified indexes.
-        /// </summary>
-        /// <param name="indexes">The indexes to be used.</param>
-        new T this[params scoped ReadOnlySpan<NIndex> indexes] { get; }
-
-        /// <summary>
-        /// Gets the values at the specified ranges.
-        /// </summary>
-        /// <param name="ranges">The ranges to be used.</param>
-        TSelf this[params scoped ReadOnlySpan<NRange> ranges] { get; }
-
-        /// <summary>
-        /// Creates a read-only tensor span for the entire underlying buffer.
-        /// </summary>
-        /// <returns>The converted <see cref="ReadOnlyTensorSpan{T}"/>.</returns>
-        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan();
-
-        /// <summary>
-        /// Creates a read-only tensor span for the specified start indexes.
-        /// </summary>
-        /// <param name="start">The start locations to be used.</param>
-        /// <returns>The converted <see cref="ReadOnlyTensorSpan{T}"/>.</returns>
-        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<nint> start);
-
-        /// <summary>
-        /// Creates a read-only tensor span for the specified start indexes.
-        /// </summary>
-        /// <param name="startIndex">The started indexes to be used.</param>
-        /// <returns>The converted <see cref="ReadOnlyTensorSpan{T}"/>.</returns>
-        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NIndex> startIndex);
-
-        /// <summary>
-        /// Creates a read-only tensor span for the specified ranges.
-        /// </summary>
-        /// <param name="range">The ranges to be used.</param>
-        /// <returns>The converted <see cref="ReadOnlyTensorSpan{T}"/>.</returns>
-        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NRange> range);
-
-        /// <summary>
-        /// Copies the tensor to the specified destination. The destination tensor must be equal to or larger than the source tensor.
-        /// </summary>
-        /// <param name="destination">The destination span where the data should be copied to.</param>
-        void CopyTo(scoped TensorSpan<T> destination);
-
-        /// <summary>
-        /// Flattens the tensor to the specified destination. The destination span must be equal to or larger than the number of elements in the source tensor.
-        /// </summary>
-        /// <param name="destination">The destination span where the data should be flattened to.</param>
-        void FlattenTo(scoped Span<T> destination);
-
-        /// <summary>
-        /// Returns a reference to the 0th element of the tensor. If the tensor is empty, returns <see langword="null"/>.
-        /// </summary>
-        /// <remarks>
-        /// This method can be used for pinning and is required to support the use of the tensor within a fixed statement.
-        /// </remarks>
-        ref readonly T GetPinnableReference();
-
-        /// <summary>
-        /// Slices the tensor using the specified start indexes.
-        /// </summary>
-        /// <param name="start">The start locations to be used.</param>
-        /// <returns>The sliced tensor.</returns>
-        TSelf Slice(params scoped ReadOnlySpan<nint> start);
-
-        /// <summary>
-        /// Slices the tensor using the specified start indexes.
-        /// </summary>
-        /// <param name="startIndex">The start indexes to be used.</param>
-        /// <returns>The sliced tensor.</returns>
-        TSelf Slice(params scoped ReadOnlySpan<NIndex> startIndex);
-
-        /// <summary>
-        /// Slices the tensor using the specified ranges.
-        /// </summary>
-        /// <param name="range">The ranges to be used.</param>
-        /// <returns>The sliced tensor.</returns>
-        TSelf Slice(params scoped ReadOnlySpan<NRange> range);
-
-        /// <summary>
-        /// Tries to copy the tensor to the specified destination. The destination tensor must be equal to or larger than the source tensor.
-        /// </summary>
-        /// <param name="destination">The destination span where the data should be copied to.</param>
-        /// <returns><see langword="true" /> if the copy succeeded, <see langword="false" /> otherwise.</returns>
-        bool TryCopyTo(scoped TensorSpan<T> destination);
-
-        /// <summary>
-        /// Tries to flatten the tensor to the specified destination. The destination span must be equal to or larger than the number of elements in the source tensor.
-        /// </summary>
-        /// <param name="destination">The destination span where the data should be flattened to.</param>
-        /// <returns><see langword="true" /> if the flatten succeeded, <see langword="false" /> otherwise.</returns>
-        bool TryFlattenTo(scoped Span<T> destination);
-    }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor_1.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor_1.cs
new file mode 100644
index 00000000000000..022140ed33aa72
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor_1.cs
@@ -0,0 +1,103 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace System.Numerics.Tensors
+{
+    /// <summary>Represents a read-only tensor.</summary>
+    /// <typeparam name="TSelf">The type that implements this interface.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
+    [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
+    public interface IReadOnlyTensor<TSelf, T> : IReadOnlyTensor, IEnumerable<T>
+        where TSelf : IReadOnlyTensor<TSelf, T>
+    {
+        /// <summary>Gets an empty tensor.</summary>
+        static abstract TSelf Empty { get; }
+
+        /// <summary>Gets a reference to the specified element of the tensor.</summary>
+        /// <param name="indexes">The index of the element for which to get a reference.</param>
+        /// <returns>A reference to the element that exists at <paramref name="indexes" />.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   Thrown when one of the following conditions is met:
+        ///   * <paramref name="indexes" /> does not contain <see cref="IReadOnlyTensor.Rank" /> elements
+        ///   * <paramref name="indexes" /> contains an element that is negative or greater than or equal to the corresponding dimension length
+        /// </exception>
+        new ref readonly T this[params scoped ReadOnlySpan<nint> indexes] { get; }
+
+        /// <inheritdoc cref="this[ReadOnlySpan{nint}]" />
+        new ref readonly T this[params scoped ReadOnlySpan<NIndex> indexes] { get; }
+
+        /// <inheritdoc cref="Slice(ReadOnlySpan{NRange})" />
+        TSelf this[params scoped ReadOnlySpan<NRange> ranges] { get; }
+
+        /// <summary>Creates a new readonly tensor span over the tensor.</summary>
+        /// <returns>The readonly tensor span representation of the tensor.</returns>
+        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan();
+
+        /// <summary>Creates a new readonly tensor span over a portion of the tensor starting at a specified position to the end of the tensor.</summary>
+        /// <param name="startIndexes">The initial indexes from which the tensor will be converted.</param>
+        /// <returns>The readonly tensor span representation of the tensor.</returns>
+        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<nint> startIndexes);
+
+        /// <inheritdoc cref="AsReadOnlyTensorSpan(ReadOnlySpan{nint})" />
+        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NIndex> startIndexes);
+
+        /// <summary>Creates a new readonly tensor span over a portion of the tensor defined by the specified range.</summary>
+        /// <param name="ranges">The ranges of the tensor to convert.</param>
+        /// <returns>The readonly tensor span representation of the tensor.</returns>
+        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NRange> ranges);
+
+        /// <summary>Copies the contents of the tensor into a destination tensor span.</summary>
+        /// <param name="destination">The destination tensor span.</param>
+        /// <exception cref="ArgumentException"><paramref name="destination" /> is shorter than the source tensor.</exception>
+        /// <remarks>This method copies all of the source tensor to <paramref name="destination" /> even if they overlap.</remarks>
+        void CopyTo(scoped in TensorSpan<T> destination);
+
+        /// <summary>Flattens the contents of the tensor into a destination span.</summary>
+        /// <param name="destination">The destination span.</param>
+        /// <exception cref="ArgumentException"><paramref name="destination" /> is shorter than the source tensor.</exception>
+        /// <remarks>This method copies all of the source tensor to <paramref name="destination" /> even if they overlap.</remarks>
+        void FlattenTo(scoped Span<T> destination);
+
+        /// <summary>Returns a reference to an object of type <typeparamref name="T" /> that can be used for pinning.</summary>
+        /// <returns>A reference to the element of the tensor at index 0, or <c>null</c> if the tensor is empty.</returns>
+        /// <remarks>This method is intended to support .NET compilers and is not intended to be called by user code.</remarks>
+        ref readonly T GetPinnableReference();
+
+        /// <summary>Forms a slice out of the current tensor that begins at a specified index.</summary>
+        /// <param name="startIndexes">The indexes at which to begin the slice.</param>
+        /// <returns>A tensor that consists of all elements of the current tensor from <paramref name="startIndexes" /> to the end of the tensor.</returns>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="startIndexes" /> is greater than the number of items in the tensor.</exception>
+        TSelf Slice(params scoped ReadOnlySpan<nint> startIndexes);
+
+        /// <inheritdoc cref="Slice(ReadOnlySpan{nint})" />
+        TSelf Slice(params scoped ReadOnlySpan<NIndex> startIndexes);
+
+        /// <summary>Gets a slice out of the current tensor that contains a specified range.</summary>
+        /// <param name="ranges">The range of which to slice.</param>
+        /// <returns>A tensor that consists of all elements of the current tensor in <paramref name="ranges" />.</returns>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="ranges" /> is larger than the tensor.</exception>
+        TSelf Slice(params scoped ReadOnlySpan<NRange> ranges);
+
+        /// <summary>Attempts to copy the contents of this tensor into a destination tensor span and returns a value to indicate whether or not the operation succeeded.</summary>
+        /// <param name="destination">The target of the copy operation.</param>
+        /// <returns><see langword="true"/> if the copy operation succeeded; otherwise, <c>false</c>.</returns>
+        /// <remarks>
+        ///   <para>If the source and <paramref name="destination" /> overlap, the entirety of the source is handled as if it was copied to a temporary location before it is copied to <paramref name="destination" />.</para>
+        ///   <para>If the <paramref name="destination" /> length is shorter than the source, no items are copied and the method returns <c>false</c>.</para>
+        /// </remarks>
+        bool TryCopyTo(scoped in TensorSpan<T> destination);
+
+        /// <summary>Attempts to flatten the contents of this tensor into a destination span and returns a value to indicate whether or not the operation succeeded.</summary>
+        /// <param name="destination">The target of the copy operation.</param>
+        /// <returns><see langword="true"/> if the copy operation succeeded; otherwise, <c>false</c>.</returns>
+        /// <remarks>
+        ///   <para>If the source and <paramref name="destination" /> overlap, the entirety of the source is handled as if it was flattened to a temporary location before it is copied to <paramref name="destination" />.</para>
+        ///   <para>If the <paramref name="destination" /> length is shorter than the source, no items are copied and the method returns <c>false</c>.</para>
+        /// </remarks>
+        bool TryFlattenTo(scoped Span<T> destination);
+    }
+}
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 4a1cbd2b1bf800..f1adace43cb916 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
@@ -6,156 +6,32 @@
 
 namespace System.Numerics.Tensors
 {
-    /// <summary>
-    /// Represents a tensor.
-    /// </summary>
+    /// <summary>Represents a tensor.</summary>
     [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
     public interface ITensor : IReadOnlyTensor
     {
-        /// <summary>
-        /// Gets the value at the specified indexes.
-        /// </summary>
-        /// <param name="indexes">The indexes to be used.</param>
-        new object this[params scoped ReadOnlySpan<nint> indexes] { get; set; }
-
-        /// <summary>
-        /// Gets the value at the specified indexes.
-        /// </summary>
-        /// <param name="indexes">The indexes to be used.</param>
-        new object this[params scoped ReadOnlySpan<NIndex> indexes] { get; set; }
-
-        /// <summary>
-        /// Gets a value that indicates whether the collection is read-only.
-        /// </summary>
+        /// <summary>Gets or sets the specified element of the tensor.</summary>
+        /// <param name="indexes">The index of the element for which to get.</param>
+        /// <returns>The element that exists at <paramref name="indexes" />.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   Thrown when one of the following conditions is met:
+        ///   * <paramref name="indexes" /> does not contain <see cref="IReadOnlyTensor.Rank" /> elements
+        ///   * <paramref name="indexes" /> contains an element that is negative or greater than or equal to the corresponding dimension length
+        /// </exception>
+        new object? this[params scoped ReadOnlySpan<nint> indexes] { get; set; }
+
+        /// <inheritdoc cref="this[ReadOnlySpan{nint}]" />
+        new object? this[params scoped ReadOnlySpan<NIndex> indexes] { get; set; }
+
+        /// <summary>Gets a value that indicates whether the tensor is read-only.</summary>
         bool IsReadOnly { get; }
 
-        /// <summary>
-        /// Clears the tensor.
-        /// </summary>
+        /// <summary>Clears the contents of the tensor span.</summary>
+        /// <remarks>This method sets the items in the tensor span to their default values. It does not remove items from the tensor span.</remarks>
         void Clear();
 
-        /// <summary>
-        /// Fills the contents of this tensor with the given value.
-        /// </summary>
+        /// <summary>Fills the elements of this tensor with a specified value.</summary>
+        /// <param name="value">The value to assign to each element of the tensor.</param>
         void Fill(object value);
     }
-
-    /// <summary>
-    /// Represents a tensor.
-    /// </summary>
-    /// <typeparam name="TSelf">The type that implements this interface.</typeparam>
-    /// <typeparam name="T">The element type.</typeparam>
-    [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
-    public interface ITensor<TSelf, T> : ITensor, IReadOnlyTensor<TSelf, T>
-        where TSelf : ITensor<TSelf, T>
-    {
-        // TODO: Determine if we can implement `IEqualityOperators<TSelf, T, bool>`.
-        // It looks like C#/.NET currently hits limitations here as it believes TSelf and T could be the same type
-        // Ideally we could annotate it such that they cannot be the same type and no conflicts would exist
-
-        /// <summary>
-        /// Creates a new tensor with the specified lengths.
-        /// </summary>
-        /// <param name="lengths">The lengths of each dimension.</param>
-        /// <param name="pinned"><see langword="true" /> to pin the underlying buffer. The default is <see langword="false" />.</param>
-        /// <remarks>
-        /// If <paramref name="pinned"/> is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned.
-        /// The underlying buffer is initialized to default values.
-        /// </remarks>
-        static abstract TSelf Create(scoped ReadOnlySpan<nint> lengths, bool pinned = false);
-
-        /// <summary>
-        /// Creates a new tensor with the specified lengths and strides.
-        /// </summary>
-        /// <param name="lengths">The lengths of each dimension.</param>
-        /// <param name="strides">The strides of each dimension.</param>
-        /// <param name="pinned"><see langword="true" /> to pin the underlying buffer. The default is <see langword="false" />.</param>
-        /// <remarks>
-        /// If <paramref name="pinned"/> is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned.
-        /// The underlying buffer is initialized to default values.
-        /// </remarks>
-        static abstract TSelf Create(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned = false);
-
-        /// <summary>
-        /// Creates a new tensor with the specified lengths and strides.
-        /// </summary>
-        /// <param name="lengths">The lengths of each dimension.</param>
-        /// <param name="pinned"><see langword="true" /> to pin the underlying buffer. The default is <see langword="false" />.</param>
-        /// <remarks>
-        /// If <paramref name="pinned"/> is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned.
-        /// The underlying buffer is not initialized.
-        /// </remarks>
-        static abstract TSelf CreateUninitialized(scoped ReadOnlySpan<nint> lengths, bool pinned = false);
-
-        /// <summary>
-        /// Creates a new tensor with the specified lengths and strides. If <paramref name="pinned"/> is true the underlying buffer is
-        /// created permanently pinned, otherwise the underlying buffer is not pinned. The underlying buffer is not initialized.
-        /// </summary>
-        /// <param name="lengths">The lengths of each dimension.</param>
-        /// <param name="strides">The strides of each dimension.</param>
-        /// <param name="pinned"><see langword="true" /> to pin the underlying buffer. The default is <see langword="false" />.</param>
-        /// <remarks>
-        /// If <paramref name="pinned"/> is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned.
-        /// The underlying buffer is not initialized.
-        /// </remarks>
-        static abstract TSelf CreateUninitialized(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned = false);
-
-        /// <summary>
-        /// Gets the value at the specified indexes.
-        /// </summary>
-        /// <param name="indexes">The indexes to use.</param>
-        new T this[params scoped ReadOnlySpan<nint> indexes] { get; set; }
-
-        /// <summary>
-        /// Gets the value at the specified indexes.
-        /// </summary>
-        /// <param name="indexes">The indexes to use.</param>
-        new T this[params scoped ReadOnlySpan<NIndex> indexes] { get; set; }
-
-        /// <summary>
-        /// Gets the values at the specified ranges.
-        /// </summary>
-        /// <param name="ranges">The ranges to be used.</param>
-        new TSelf this[params scoped ReadOnlySpan<NRange> ranges] { get; set; }
-
-        /// <summary>
-        /// Creates a tensor span for the entire underlying buffer.
-        /// </summary>
-        /// <returns>The converted <see cref="TensorSpan{T}"/>.</returns>
-        TensorSpan<T> AsTensorSpan();
-
-        /// <summary>
-        /// Creates a tensor span for the specified start indexes.
-        /// </summary>
-        /// <param name="start">The start locations to be used.</param>
-        /// <returns>The converted <see cref="TensorSpan{T}"/>.</returns>
-        TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<nint> start);
-
-        /// <summary>
-        /// Creates a tensor span for the specified start indexes.
-        /// </summary>
-        /// <param name="startIndex">The start indexes to be used.</param>
-        /// <returns>The converted <see cref="TensorSpan{T}"/>.</returns>
-        TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<NIndex> startIndex);
-
-        /// <summary>
-        /// Creates a tensor span for the specified ranges.
-        /// </summary>
-        /// <param name="range">The ranges to be used.</param>
-        /// <returns>The converted <see cref="TensorSpan{T}"/>.</returns>
-        TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<NRange> range);
-
-        /// <summary>
-        /// Fills the contents of this tensor with the given value.
-        /// </summary>
-        void Fill(T value);
-
-        /// <summary>
-        /// Returns a reference to the 0th element of the tensor. If the tensor is empty, returns <see langword="null"/>.
-        /// </summary>
-        /// <remarks>
-        /// This method can be used for pinning and is required to support the use of the tensor within a fixed statement.
-        /// </remarks>
-        new ref T GetPinnableReference();
-    }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor_1.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor_1.cs
new file mode 100644
index 00000000000000..8be1445275e3fb
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor_1.cs
@@ -0,0 +1,93 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
+
+namespace System.Numerics.Tensors
+{
+    /// <summary>Represents a tensor.</summary>
+    /// <typeparam name="TSelf">The type that implements this interface.</typeparam>
+    /// <typeparam name="T">The element type.</typeparam>
+    [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
+    public interface ITensor<TSelf, T> : ITensor, IReadOnlyTensor<TSelf, T>
+        where TSelf : ITensor<TSelf, T>
+    {
+        // TODO: Determine if we can implement `IEqualityOperators<TSelf, T, bool>`.
+        // It looks like C#/.NET currently hits limitations here as it believes TSelf and T could be the same type
+        // Ideally we could annotate it such that they cannot be the same type and no conflicts would exist
+
+        /// <summary>Creates a new tensor with the specified lengths.</summary>
+        /// <param name="lengths">The lengths of each dimension.</param>
+        /// <param name="pinned"><see langword="true" /> to pin the underlying buffer. The default is <see langword="false" />.</param>
+        /// <remarks>
+        ///   <para>If <paramref name="pinned"/> is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned.</para>
+        ///   <para>The underlying buffer is initialized to default values.</para>
+        /// </remarks>
+        static abstract TSelf Create(scoped ReadOnlySpan<nint> lengths, bool pinned = false);
+
+        /// <summary>Creates a new tensor with the specified lengths and strides.</summary>
+        /// <param name="lengths">The lengths of each dimension.</param>
+        /// <param name="strides">The strides of each dimension.</param>
+        /// <param name="pinned"><see langword="true" /> to pin the underlying buffer. The default is <see langword="false" />.</param>
+        /// <remarks>
+        ///   <para>If <paramref name="pinned"/> is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned.</para>
+        ///   <para>The underlying buffer is initialized to default values.</para>
+        /// </remarks>
+        static abstract TSelf Create(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned = false);
+
+        /// <summary>Creates a new tensor with the specified lengths and strides.</summary>
+        /// <param name="lengths">The lengths of each dimension.</param>
+        /// <param name="pinned"><see langword="true" /> to pin the underlying buffer. The default is <see langword="false" />.</param>
+        /// <remarks>
+        ///   <para>If <paramref name="pinned"/> is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned.</para>
+        ///   <para>The underlying buffer is not initialized.</para>
+        /// </remarks>
+        static abstract TSelf CreateUninitialized(scoped ReadOnlySpan<nint> lengths, bool pinned = false);
+
+        /// <summary>Creates a new tensor with the specified lengths and strides. If <paramref name="pinned"/> is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned. The underlying buffer is not initialized.</summary>
+        /// <param name="lengths">The lengths of each dimension.</param>
+        /// <param name="strides">The strides of each dimension.</param>
+        /// <param name="pinned"><see langword="true" /> to pin the underlying buffer. The default is <see langword="false" />.</param>
+        /// <remarks>
+        ///   If <paramref name="pinned"/> is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned.
+        /// The underlying buffer is not initialized.
+        /// </remarks>
+        static abstract TSelf CreateUninitialized(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned = false);
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.this[ReadOnlySpan{nint}]" />
+        new ref T this[params scoped ReadOnlySpan<nint> indexes] { get; }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.this[ReadOnlySpan{NIndex}]" />
+        new ref T this[params scoped ReadOnlySpan<NIndex> indexes] { get; }
+
+        /// <summary>Gets or sets a slice out of the current tensor that contains a specified range.</summary>
+        /// <param name="ranges">The range of which to slice.</param>
+        /// <returns>A tensor that consists of all elements of the current tensor in <paramref name="ranges" />.</returns>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="ranges" /> is larger than the tensor.</exception>
+        new TSelf this[params scoped ReadOnlySpan<NRange> ranges] { get; set; }
+
+        /// <summary>Creates a new tensor span over the tensor.</summary>
+        /// <returns>The tensor span representation of the tensor.</returns>
+        TensorSpan<T> AsTensorSpan();
+
+        /// <summary>Creates a new tensor span over a portion of the tensor starting at a specified position to the end of the tensor.</summary>
+        /// <param name="startIndexes">The initial indexes from which the tensor will be converted.</param>
+        /// <returns>The tensor span representation of the tensor.</returns>
+        TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<nint> startIndexes);
+
+        /// <inheritdoc cref="AsTensorSpan(ReadOnlySpan{nint})" />
+        TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<NIndex> startIndexes);
+
+        /// <summary>Creates a new tensor span over a portion of the tensor defined by the specified range.</summary>
+        /// <param name="ranges">The ranges of the tensor to convert.</param>
+        /// <returns>The tensor span representation of the tensor.</returns>
+        TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<NRange> ranges);
+
+        /// <inheritdoc cref="ITensor.Fill(object)" />
+        void Fill(T value);
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.GetPinnableReference" />
+        new ref T GetPinnableReference();
+    }
+}
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
deleted file mode 100644
index c4bdb876dd627d..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs
+++ /dev/null
@@ -1,828 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Buffers;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using EditorBrowsableAttribute = System.ComponentModel.EditorBrowsableAttribute;
-using EditorBrowsableState = System.ComponentModel.EditorBrowsableState;
-
-#pragma warning disable 0809  //warning CS0809: Obsolete member 'ReadOnlyTensorSpan<T>.Equals(object)' overrides non-obsolete member 'object.Equals(object)'
-
-namespace System.Numerics.Tensors
-{
-    /// <summary>
-    /// Represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed
-    /// or native memory, or to memory allocated on the stack. It is type-safe and memory-safe.
-    /// </summary>
-    [DebuggerTypeProxy(typeof(TensorSpanDebugView<>))]
-    [DebuggerDisplay("{ToString(),raw}")]
-    [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
-    public readonly ref struct ReadOnlyTensorSpan<T>
-    {
-        /// <summary>A byref or a native ptr.</summary>
-        internal readonly ref T _reference;
-        internal readonly TensorShape _shape;
-
-
-        /// <summary>
-        /// Creates a new span over the entirety of the target array.
-        /// </summary>
-        /// <param name="array">The target array.</param>
-        /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
-        /// <exception cref="ArrayTypeMismatchException"><paramref name="array"/> is covariant and its type is not exactly T[].</exception>
-        public ReadOnlyTensorSpan(T[]? array) : this(array, 0, [array?.Length ?? 0], [])
-        {
-        }
-
-        /// <summary>
-        /// Creates a new span over the portion of the target array beginning
-        /// at 'start' index and ending at 'end' index (exclusive).
-        /// </summary>
-        /// <param name="array">The target array.</param>
-        /// <param name="startIndex">The index at which to begin the span.</param>
-        /// <param name="lengths">The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data.</param>
-        /// <param name="strides">The strides of each dimension. If default or span of length 0 is provided, then strides will be automatically calculated.</param>
-        /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
-        /// <exception cref="ArrayTypeMismatchException"><paramref name="array"/> is covariant and its type is not exactly T[].</exception>
-        /// <exception cref="ArgumentOutOfRangeException">The specified <paramref name="startIndex"/> or end index is not in the range (&lt;0 or &gt;FlattenedLength).
-        /// </exception>
-        public ReadOnlyTensorSpan(T[]? array, Index startIndex, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
-            : this(array, startIndex.GetOffset(array?.Length ?? 0), lengths, strides)
-        {
-        }
-
-        /// <summary>
-        /// Creates a new span over the portion of the target array beginning
-        /// at 'start' index and ending at 'end' index (exclusive).
-        /// </summary>
-        /// <param name="array">The target array.</param>
-        /// <param name="start">The index at which to begin the span.</param>
-        /// <param name="lengths">The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data.</param>
-        /// <param name="strides">The strides of each dimension. If default or span of length 0 is provided, then strides will be automatically calculated.</param>
-        /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
-        /// <exception cref="ArrayTypeMismatchException"><paramref name="array"/> is covariant and its type is not exactly T[].</exception>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// Thrown when the specified <paramref name="start"/> or end index is not in the range (&lt;0 or &gt;FlattenedLength).
-        /// </exception>
-        [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)
-            {
-                if (start != 0 || linearLength != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-                this = default;
-                return; // returns default
-            }
-
-            if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
-                ThrowHelper.ThrowArrayTypeMismatchException();
-
-            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 && array.Length != 0)
-                    ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
-            }
-            else
-            {
-                if (((uint)start > (uint)array.Length || (uint)maxElements >= (uint)(array.Length - start)) && array.Length != 0)
-                    ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
-            }
-
-            _shape = new TensorShape(array.Length - start, lengths, strides);
-            _reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */);
-        }
-
-        /// <summary>
-        /// 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], []) { }
-
-        /// <summary>
-        /// Creates a new <see cref="ReadOnlyTensorSpan{T}"/> over the provided <see cref="Span{T}"/> using the specified lengths and strides.
-        /// </summary>
-        /// <param name="span">The target span.</param>
-        /// <param name="lengths">The lengths of each dimension.</param>
-        /// <param name="strides">The strides for each dimension. The strides 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);
-
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
-            TensorSpanHelpers.ValidateStrides(strides, lengths);
-            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
-            if (span.IsEmpty ? maxElements != 0 : maxElements >= span.Length)
-                ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
-
-            _shape = new TensorShape(span.Length, lengths, strides);
-            _reference = ref MemoryMarshal.GetReference(span);
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="ReadOnlyTensorSpan{T}"/> over the provided <see cref="Array"/>. The new <see cref="ReadOnlyTensorSpan{T}"/> will
-        /// 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,
-                 array == null ?
-                    [0] :
-                    TensorSpanHelpers.FillLengths(array.Rank <= TensorShape.MaxInlineRank ?
-                        stackalloc nint[array.Rank] :
-                        new nint[array.Rank], array),
-                 [])
-        {
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="ReadOnlyTensorSpan{T}"/> over the provided <see cref="Array"/> using the specified start offsets, lengths, and strides.
-        /// </summary>
-        /// <param name="array">The target array.</param>
-        /// <param name="start">The starting offset for each dimension.</param>
-        /// <param name="lengths">The lengths of each dimension.</param>
-        /// <param name="strides">The strides for each dimension. This strides 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 = TensorSpanHelpers.FillLengths(
-                    array.Rank <= TensorShape.MaxInlineRank ? stackalloc nint[array.Rank] : new nint[array.Rank],
-                    array);
-            }
-
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            if (array == null)
-            {
-                if (!start.IsEmpty || linearLength != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-                this = default;
-                return; // returns default
-            }
-            if (array.GetType().GetElementType() != typeof(T))
-                ThrowHelper.ThrowArrayTypeMismatchException();
-
-            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 && array.Length != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-            }
-            else
-            {
-                if (((uint)startOffset > (uint)array.Length || (uint)maxElements >= (uint)(array.Length - startOffset)) && array.Length != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-            }
-
-            _shape = new TensorShape(array.Length - startOffset, lengths, strides);
-            _reference = ref Unsafe.Add(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), (nint)(uint)startOffset /* force zero-extension */);
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="ReadOnlyTensorSpan{T}"/> over the provided <see cref="Array"/> using the specified start offsets, lengths, and strides.
-        /// </summary>
-        /// <param name="array">The target array.</param>
-        /// <param name="startIndex">The starting offset for each dimension.</param>
-        /// <param name="lengths">The lengths of each dimension.</param>
-        /// <param name="strides">The strides for each dimension. The strides 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 = TensorSpanHelpers.FillLengths(
-                    array.Rank <= TensorShape.MaxInlineRank ? stackalloc nint[array.Rank] : new nint[array.Rank],
-                    array);
-            }
-
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            if (array == null)
-            {
-                if (!startIndex.IsEmpty || linearLength != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-                this = default;
-                return; // returns default
-            }
-            if (array.GetType().GetElementType() != typeof(T))
-                ThrowHelper.ThrowArrayTypeMismatchException();
-
-            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)startOffset + (ulong)(uint)maxElements > (ulong)(uint)array.Length)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-            }
-            else
-            {
-                if ((uint)startOffset > (uint)array.Length || (uint)maxElements >= (uint)(array.Length - startOffset))
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-            }
-
-            _shape = new TensorShape(array.Length - startOffset, lengths, strides);
-            _reference = ref Unsafe.Add(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), (nint)(uint)startOffset /* force zero-extension */);
-        }
-
-        /// <summary>
-        /// Creates a new span over the target unmanaged buffer.
-        /// </summary>
-        /// <param name="data">An unmanaged data that points to memory.</param>
-        /// <param name="dataLength">The number of elements the unmanaged memory can hold.</param>
-        /// <remarks>
-        /// This constructor is quite dangerous, because the length is not checked.
-        /// But if this creation is correct, then all subsequent uses are correct.
-        /// </remarks>
-        [CLSCompliant(false)]
-        public unsafe ReadOnlyTensorSpan(T* data, nint dataLength) : this(data, dataLength, [dataLength], []) { }
-
-        /// <summary>
-        /// Creates a new span over the target unmanaged buffer.
-        /// </summary>
-        /// <param name="data">An unmanaged data that points to memory.</param>
-        /// <param name="dataLength">The number of elements the unmanaged memory can hold.</param>
-        /// <param name="lengths">The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data.</param>
-        /// <param name="strides">The lengths of the strides. If nothing is provided, it figures out the default stride configuration.</param>
-        /// <exception cref="ArgumentException">
-        /// <typeparamref name="T"/> is a reference type or contains pointers and hence cannot be stored in unmanaged memory.
-        /// </exception>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// The specified length is negative.
-        /// </exception>
-        /// <remarks>
-        /// This constructor is quite dangerous, because the length is not checked.
-        /// But if this creation is correct, then all subsequent uses are correct.
-        /// </remarks>
-        [CLSCompliant(false)]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe ReadOnlyTensorSpan(T* data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
-        {
-            if (dataLength < 0)
-                ThrowHelper.ThrowArgumentOutOfRangeException();
-
-            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
-                ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
-
-            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();
-
-            _shape = new TensorShape(dataLength, lengths, strides);
-            _reference = ref *data;
-        }
-
-        // Constructor for internal use only. It is not safe to expose publicly.
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal ReadOnlyTensorSpan(ref T reference, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, nint memoryLength)
-        {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-
-            _shape = new TensorShape(memoryLength, lengths, strides);
-            _reference = ref reference;
-        }
-
-        /// <summary>
-        /// Returns a reference to specified element of the ReadOnlyTensorSpan.
-        /// </summary>
-        /// <param name="indexes"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Any index is less than 0 or any index is greater than or equal to FlattenedLength.
-        /// </exception>
-        public ref readonly T this[params scoped ReadOnlySpan<nint> indexes]
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get
-            {
-                if (indexes.Length != Rank)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-
-                nint index = TensorSpanHelpers.ComputeLinearIndex(indexes, Strides, Lengths);
-                if (index >= _shape._memoryLength || index < 0)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-
-                return ref Unsafe.Add(ref _reference, index /* force zero-extension */);
-            }
-        }
-
-        /// <summary>
-        /// Returns a reference to specified element of the ReadOnlyTensorSpan.
-        /// </summary>
-        /// <param name="indexes"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Any index is less than 0 or any index is greater than or equal to FlattenedLength.
-        /// </exception>
-        public ref readonly T this[params scoped ReadOnlySpan<NIndex> indexes]
-        {
-            get
-            {
-                if (indexes.Length != Rank)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-
-                nint index = TensorSpanHelpers.ComputeLinearIndex(indexes, Strides, Lengths);
-                if (index >= _shape._memoryLength || index < 0)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-
-                return ref Unsafe.Add(ref _reference, index /* force zero-extension */);
-            }
-        }
-
-        /// <summary>
-        /// Returns a slice of the ReadOnlyTensorSpan.
-        /// </summary>
-        /// <param name="ranges"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Any index is less than 0 or any index is greater than or equal to FlattenedLength.
-        /// </exception>
-        public ReadOnlyTensorSpan<T> this[params scoped ReadOnlySpan<NRange> ranges]
-        {
-            get
-            {
-                if (ranges.Length != Rank)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-
-                return Slice(ranges);
-            }
-        }
-
-        /// <summary>
-        /// Gets the number of items in the span.
-        /// </summary>
-        public nint FlattenedLength => _shape.FlattenedLength;
-
-        /// <summary>
-        /// Gets a value indicating whether this <see cref="TensorSpan{T}"/> is empty.
-        /// </summary>
-        /// <value><see langword="true"/> if this span is empty; otherwise, <see langword="false"/>.</value>
-        public bool IsEmpty => _shape.IsEmpty;
-
-        /// <summary>
-        /// Gets the length of each dimension in this <see cref="TensorSpan{T}"/>.
-        /// </summary>
-        [UnscopedRef]
-        public ReadOnlySpan<nint> Lengths => _shape.Lengths;
-
-        /// <summary>
-        /// Gets the rank, or number of dimensions, of this <see cref="TensorSpan{T}"/>.
-        /// </summary>
-        public int Rank => Lengths.Length;
-
-        /// <summary>
-        /// Gets the strides of this <see cref="TensorSpan{T}"/>.
-        /// </summary>
-        [UnscopedRef]
-        public ReadOnlySpan<nint> Strides => _shape.Strides;
-
-        /// <summary>
-        /// Compares the given spans and returns false if left and right point at the same memory and have the same length.
-        /// This opertor does *not* check to see if the *contents* are equal.
-        /// </summary>
-        public static bool operator !=(ReadOnlyTensorSpan<T> left, ReadOnlyTensorSpan<T> right) => !(left == right);
-
-        /// <summary>
-        /// Compares the given spans and returns true if left and right point at the same memory and have the same length.
-        /// This operator does *not* check to see if the *contents* are equal.
-        /// </summary>
-        public static bool operator ==(ReadOnlyTensorSpan<T> left, ReadOnlyTensorSpan<T> right) =>
-            left._shape.FlattenedLength == right._shape.FlattenedLength &&
-            left.Rank == right.Rank &&
-            left._shape.Lengths.SequenceEqual(right._shape.Lengths )&&
-            Unsafe.AreSame(ref left._reference, ref right._reference);
-
-        /// <summary>
-        /// This method is not supported as spans cannot be boxed. To compare two spans, use operator ==.
-        /// </summary>
-        /// <exception cref="NotSupportedException">
-        /// In all cases.
-        /// </exception>
-#pragma warning disable CS0809 // Obsolete member overrides non-obsolete member
-        [Obsolete("Equals() on ReadOnlyTensorSpan will always throw an exception. Use the equality operator instead.")]
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        public override bool Equals(object? obj) =>
-            throw new NotSupportedException(SR.NotSupported_CannotCallEqualsOnSpan);
-
-        /// <summary>
-        /// This method is not supported as spans cannot be boxed.
-        /// </summary>
-        /// <exception cref="NotSupportedException">
-        /// In all cases.
-        /// </exception>
-        [Obsolete("GetHashCode() on ReadOnlyTensorSpan will always throw an exception.")]
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        public override int GetHashCode() =>
-            throw new NotSupportedException(SR.NotSupported_CannotCallGetHashCodeOnSpan);
-#pragma warning restore CS0809
-
-        /// <summary>
-        /// Returns a 0-length read-only span whose base is the null pointer.
-        /// </summary>
-        public static ReadOnlyTensorSpan<T> Empty => default;
-
-        /// <summary>
-        /// Casts a read-only span of <typeparamref name="TDerived"/> to a read-only span of <typeparamref name="T"/>.
-        /// </summary>
-        /// <typeparam name="TDerived">The element type of the source read-only span, which must be derived from <typeparamref name="T"/>.</typeparam>
-        /// <param name="items">The source read-only span. No copy is made.</param>
-        /// <returns>A read-only span with elements cast to the new type.</returns>
-        /// <remarks>This method uses a covariant cast, producing a read-only span that shares the same memory as the source. The relationships expressed in the type constraints ensure that the cast is a safe operation.</remarks>
-        public static ReadOnlyTensorSpan<T> CastUp<TDerived>(ReadOnlyTensorSpan<TDerived> items) where TDerived : class?, T
-        {
-            return new ReadOnlyTensorSpan<T>(ref Unsafe.As<TDerived, T>(ref items._reference), items._shape.Lengths, items._shape.Strides, items._shape._memoryLength);
-        }
-
-        /// <summary>Gets an enumerator for this span.</summary>
-        public Enumerator GetEnumerator() => new Enumerator(this);
-
-        /// <summary>Enumerates the elements of a <see cref="ReadOnlyTensorSpan{T}"/>.</summary>
-        public ref struct Enumerator
-        {
-            /// <summary>The span being enumerated.</summary>
-            private readonly ReadOnlyTensorSpan<T> _span;
-            /// <summary>The current index that the enumerator is on.</summary>
-            private Span<nint> _curIndexes;
-            /// <summary>The total item count.</summary>
-            private nint _items;
-
-            /// <summary>Initializes the enumerator.</summary>
-            /// <param name="span">The span to enumerate.</param>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal Enumerator(ReadOnlyTensorSpan<T> span)
-            {
-                _span = span;
-                _items = -1;
-                _curIndexes = new nint[_span.Rank];
-                _curIndexes[_span.Rank - 1] = -1;
-            }
-
-            /// <summary>Advances the enumerator to the next element of the span.</summary>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool MoveNext()
-            {
-                TensorSpanHelpers.AdjustIndexes(_span.Rank - 1, 1, _curIndexes, _span.Lengths);
-
-                if (_items < _span.FlattenedLength)
-                    _items++;
-
-                return _items < _span.FlattenedLength;
-            }
-
-            /// <summary>Gets the element at the current position of the enumerator.</summary>
-            public ref readonly T Current
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get => ref _span[_curIndexes];
-            }
-        }
-
-        /// <summary>
-        /// Returns a reference to the 0th element of the ReadOnlyTensorSpan. If the ReadOnlyTensorSpan is empty, returns null reference.
-        /// </summary>
-        /// <remarks>
-        /// This method can be used for pinning and is required to support the use of span within a fixed statement.
-        /// </remarks>
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        public ref readonly T GetPinnableReference()
-        {
-            // Ensure that the native code has just one forward branch that is predicted-not-taken.
-            ref T ret = ref Unsafe.NullRef<T>();
-            if (_shape.FlattenedLength != 0) ret = ref _reference;
-            return ref ret;
-        }
-
-        /// <summary>
-        /// Copies the contents of this read-only span into destination span. If the source
-        /// and destinations overlap, this method behaves as if the original values are in
-        /// a temporary location before the destination is overwritten.
-        /// </summary>
-        /// <param name="destination">The span to copy items into.</param>
-        /// <exception cref="ArgumentException">
-        /// The destination ReadOnlyTensorSpan is shorter than the source ReadOnlyTensorSpan.
-        /// </exception>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CopyTo(scoped TensorSpan<T> destination)
-        {
-            // Using "if (!TryCopyTo(...))" results in two branches: one for the length
-            // check, and one for the result of TryCopyTo. Since these checks are equivalent,
-            // we can optimize by performing the check once ourselves then calling Memmove directly.
-            if (TensorHelpers.IsBroadcastableTo(Lengths, destination.Lengths))
-            {
-                scoped Span<nint> curIndexes;
-                nint[]? curIndexesArray;
-
-                if (Rank > TensorShape.MaxInlineRank)
-                {
-                    curIndexesArray = ArrayPool<nint>.Shared.Rent(destination.Rank);
-                    curIndexes = curIndexesArray.AsSpan(0, destination.Rank);
-
-                }
-                else
-                {
-                    curIndexesArray = null;
-                    curIndexes = stackalloc nint[destination.Rank];
-                }
-                curIndexes.Clear();
-
-                nint copiedValues = 0;
-                nint[] tempLengths = Tensor.GetSmallestBroadcastableLengths(Lengths, destination.Lengths);
-
-                TensorSpan<T> destinationSlice = destination.Slice(tempLengths);
-                ReadOnlyTensorSpan<T> srcSlice = Tensor.LazyBroadcast(this, tempLengths);
-                nint copyLength = srcSlice.Strides[^1] == 1 && TensorHelpers.IsContiguousAndDense(srcSlice) ? srcSlice.Lengths[^1] : 1;
-                int indexToAdjust = srcSlice.Strides[^1] == 1 && TensorHelpers.IsContiguousAndDense(srcSlice) ? srcSlice.Rank - 2 : srcSlice.Rank - 1;
-
-                while (copiedValues < destination.FlattenedLength)
-                {
-                    TensorSpanHelpers.Memmove(ref Unsafe.Add(ref destinationSlice._reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, destinationSlice.Strides, destinationSlice.Lengths)), ref Unsafe.Add(ref srcSlice._reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, srcSlice.Strides, srcSlice.Lengths)), copyLength);
-                    TensorSpanHelpers.AdjustIndexes(indexToAdjust, 1, curIndexes, tempLengths);
-                    copiedValues += copyLength;
-                }
-                Debug.Assert(copiedValues == destination.FlattenedLength, "Didn't copy the right amount to the array.");
-
-                if (curIndexesArray != null)
-                    ArrayPool<nint>.Shared.Return(curIndexesArray);
-            }
-            else
-            {
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-            }
-        }
-
-        /// <summary>
-        /// Copies the contents of this read-only span into destination span.
-        /// </summary>
-        /// <returns><see langword="true"/> if the copy succeeded; <see langword="false"/> if the destination span is shorter than the source span and no data is written to the destination.</returns>
-        /// <param name="destination">The span to copy items into.</param>
-        /// <remarks>
-        /// If the source and destinations overlap, this method behaves as if
-        /// the original values are in a temporary location before the destination is overwritten.
-        /// </remarks>
-        public bool TryCopyTo(scoped TensorSpan<T> destination)
-        {
-            bool retVal = false;
-
-            if (TensorHelpers.IsBroadcastableTo(Lengths, destination.Lengths))
-            {
-                scoped Span<nint> curIndexes;
-                nint[]? curIndexesArray;
-
-                if (Rank > TensorShape.MaxInlineRank)
-                {
-                    curIndexesArray = ArrayPool<nint>.Shared.Rent(destination.Rank);
-                    curIndexes = curIndexesArray.AsSpan(0, destination.Rank);
-
-                }
-                else
-                {
-                    curIndexesArray = null;
-                    curIndexes = stackalloc nint[destination.Rank];
-                }
-                curIndexes.Clear();
-
-                nint copiedValues = 0;
-                nint[] tempLengths = Tensor.GetSmallestBroadcastableLengths(Lengths, destination.Lengths);
-
-                TensorSpan<T> destinationSlice = destination.Slice(tempLengths);
-                ReadOnlyTensorSpan<T> srcSlice = Tensor.LazyBroadcast(this, tempLengths);
-                nint copyLength = srcSlice.Strides[^1] == 1 && TensorHelpers.IsContiguousAndDense(srcSlice) ? srcSlice.Lengths[^1] : 1;
-                int indexToAdjust = srcSlice.Strides[^1] == 1 && TensorHelpers.IsContiguousAndDense(srcSlice) ? srcSlice.Rank - 2 : srcSlice.Rank - 1;
-
-                while (copiedValues < destination.FlattenedLength)
-                {
-                    TensorSpanHelpers.Memmove(ref Unsafe.Add(ref destinationSlice._reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, destinationSlice.Strides, destinationSlice.Lengths)), ref Unsafe.Add(ref srcSlice._reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, srcSlice.Strides, srcSlice.Lengths)), copyLength);
-                    TensorSpanHelpers.AdjustIndexes(indexToAdjust, 1, curIndexes, tempLengths);
-                    copiedValues += copyLength;
-                }
-                Debug.Assert(copiedValues == destination.FlattenedLength, "Didn't copy the right amount to the array.");
-                retVal = true;
-
-                if (curIndexesArray != null)
-                    ArrayPool<nint>.Shared.Return(curIndexesArray);
-            }
-
-            return retVal;
-        }
-
-        /// <summary>
-        /// Defines an implicit conversion of an array to a <see cref="TensorSpan{T}"/>.
-        /// </summary>
-        public static implicit operator ReadOnlyTensorSpan<T>(T[]? array) => new ReadOnlyTensorSpan<T>(array);
-
-        /// <summary>
-        /// Returns a <see cref="string"/> with the name of the type and the number of elements.
-        /// </summary>
-        public override string ToString() => $"System.Numerics.Tensors.ReadOnlyTensorSpan<{typeof(T).Name}>[{_shape.FlattenedLength}]";
-
-        /// <summary>
-        /// Returns a reference to specified element of the TensorSpan.
-        /// </summary>
-        /// <param name="indexes">The indexes for the slice.</param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">Any index is less than 0 or greater than or equal to FlattenedLength.
-        /// </exception>
-        public ReadOnlyTensorSpan<T> Slice(params scoped ReadOnlySpan<NIndex> indexes)
-        {
-            NRange[] ranges = new NRange[indexes.Length];
-            for (int i = 0; i < indexes.Length; i++)
-            {
-                ranges[i] = new NRange(checked((int)indexes[i].GetOffset(Lengths[i])), Lengths[i]);
-            }
-            return Slice(ranges);
-        }
-
-        /// <summary>
-        /// Takes in the lengths of the dimensions and slices according to them.
-        /// </summary>
-        /// <param name="lengths">The dimension lengths.</param>
-        /// <returns>A <see cref="ReadOnlyTensorSpan{T}"/> based on the provided <paramref name="lengths"/>.</returns>
-        internal ReadOnlyTensorSpan<T> Slice(scoped ReadOnlySpan<nint> lengths)
-        {
-            NRange[] ranges = new NRange[lengths.Length];
-            for (int i = 0; i < lengths.Length; i++)
-            {
-                ranges[i] = new NRange(0, lengths[i]);
-            }
-            return Slice(ranges);
-        }
-
-        /// <summary>
-        /// Forms a slice out of the given span.
-        /// </summary>
-        /// <param name="ranges">The ranges for the slice.</param>
-        /// <returns>A <see cref="ReadOnlyTensorSpan{T}"/> based on the provided <paramref name="ranges"/>.</returns>
-
-        public ReadOnlyTensorSpan<T> Slice(params scoped ReadOnlySpan<NRange> ranges)
-        {
-            if (ranges.Length != Lengths.Length)
-                throw new ArgumentOutOfRangeException(nameof(ranges), "Number of dimensions to slice does not equal the number of dimensions in the span");
-
-            ReadOnlyTensorSpan<T> toReturn;
-            scoped Span<nint> lengths;
-            scoped Span<nint> offsets;
-            nint[]? lengthsArray;
-            nint[]? offsetsArray;
-            if (Rank > TensorShape.MaxInlineRank)
-            {
-                lengthsArray = ArrayPool<nint>.Shared.Rent(Rank);
-                lengths = lengthsArray.AsSpan(0, Rank);
-
-                offsetsArray = ArrayPool<nint>.Shared.Rent(Rank);
-                offsets = offsetsArray.AsSpan(0, Rank);
-            }
-            else
-            {
-                lengths = stackalloc nint[Rank];
-                offsets = stackalloc nint[Rank];
-
-                lengthsArray = null;
-                offsetsArray = null;
-            }
-            lengths.Clear();
-            offsets.Clear();
-
-            for (int i = 0; i < ranges.Length; i++)
-            {
-                (offsets[i], lengths[i]) = ranges[i].GetOffsetAndLength(Lengths[i]);
-            }
-
-            // FlattenedLength is computed everytime so using a local to cache the value.
-            nint flattenedLength = FlattenedLength;
-            nint index = 0;
-
-            if (flattenedLength != 0)
-            {
-                for (int i = 0; i < offsets.Length; i++)
-                {
-                    index += Strides[i] * (offsets[i]);
-                }
-            }
-
-            if ((index >= _shape._memoryLength || index < 0) && flattenedLength != 0)
-                ThrowHelper.ThrowIndexOutOfRangeException();
-
-            toReturn = new ReadOnlyTensorSpan<T>(ref Unsafe.Add(ref _reference, index), lengths, _shape.Strides, _shape._memoryLength - index);
-
-            if (offsetsArray != null)
-                ArrayPool<nint>.Shared.Return(offsetsArray);
-            if (lengthsArray != null)
-                ArrayPool<nint>.Shared.Return(lengthsArray);
-
-            return toReturn;
-        }
-
-        /// <summary>
-        /// Flattens the contents of this span into the provided <see cref="Span{T}"/>.
-        /// </summary>
-        /// <param name="destination">The span to copy items into.</param>
-        public bool TryFlattenTo(scoped Span<T> destination)
-        {
-            bool retVal = false;
-            if (destination.Length < _shape.FlattenedLength)
-            {
-                scoped Span<nint> curIndexes;
-                nint[]? curIndexesArray;
-                if (Rank > TensorShape.MaxInlineRank)
-                {
-                    curIndexesArray = ArrayPool<nint>.Shared.Rent(Rank);
-                    curIndexes = curIndexesArray.AsSpan(0, Rank);
-                }
-                else
-                {
-                    curIndexesArray = null;
-                    curIndexes = stackalloc nint[Rank];
-                }
-                curIndexes.Clear();
-
-                nint copiedValues = 0;
-                while (copiedValues < _shape.FlattenedLength)
-                {
-                    TensorSpanHelpers.Memmove(destination.Slice(checked((int)copiedValues)), ref Unsafe.Add(ref _reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, Strides, Lengths)), Lengths[Rank - 1]);
-                    TensorSpanHelpers.AdjustIndexes(Rank - 2, 1, curIndexes, _shape.Lengths);
-                    copiedValues += Lengths[Rank - 1];
-                }
-
-                if (curIndexesArray != null)
-                    ArrayPool<nint>.Shared.Return(curIndexesArray);
-                retVal = true;
-            }
-            return retVal;
-        }
-
-        /// <summary>
-        /// Flattens the contents of this span into the provided <see cref="Span{T}"/>.
-        /// </summary>
-        /// <param name="destination">The span to copy items into.</param>
-        public void FlattenTo(scoped Span<T> destination)
-        {
-            if (destination.Length < _shape.FlattenedLength)
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-
-            if (_shape.FlattenedLength == 0)
-                return;
-
-            scoped Span<nint> curIndexes;
-            nint[]? curIndexesArray;
-            if (Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexesArray = ArrayPool<nint>.Shared.Rent(Rank);
-                curIndexes = curIndexesArray.AsSpan(0, Rank);
-            }
-            else
-            {
-                curIndexesArray = null;
-                curIndexes = stackalloc nint[Rank];
-            }
-            curIndexes.Clear();
-
-            nint copiedValues = 0;
-            while (copiedValues < _shape.FlattenedLength)
-            {
-                if (Strides[Rank - 1] == 0)
-                {
-                    destination.Slice(checked((int)copiedValues), (int)Lengths[Rank - 1]).Fill(Unsafe.Add(ref _reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, Strides, Lengths)));
-                }
-                else
-                {
-                    TensorSpanHelpers.Memmove(destination.Slice(checked((int)copiedValues)), ref Unsafe.Add(ref _reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, Strides, Lengths)), Lengths[Rank - 1]);
-                }
-                TensorSpanHelpers.AdjustIndexes(Rank - 2, 1, curIndexes, _shape.Lengths);
-                copiedValues += Lengths[Rank - 1];
-            }
-
-            if (curIndexesArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexesArray);
-        }
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan_1.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan_1.cs
new file mode 100644
index 00000000000000..36452121c96ebd
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan_1.cs
@@ -0,0 +1,524 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+#pragma warning disable CS0809 // Obsolete member overrides non-obsolete member
+
+namespace System.Numerics.Tensors
+{
+    /// <summary>
+    /// Represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed
+    /// or native memory, or to memory allocated on the stack. It is type-safe and memory-safe.
+    /// </summary>
+    [DebuggerTypeProxy(typeof(TensorSpanDebugView<>))]
+    [DebuggerDisplay("{ToString(),raw}")]
+    [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
+    public readonly ref struct ReadOnlyTensorSpan<T>
+    {
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Empty" />
+        public static ReadOnlyTensorSpan<T> Empty => default;
+
+        internal readonly TensorShape _shape;
+        internal readonly ref T _reference;
+
+        /// <summary>Creates a new tensor over the entirety of the target array.</summary>
+        /// <param name="array">The target array.</param>
+        /// <remarks>
+        ///   <para>Returns default when <paramref name="array"/> is null.</para>
+        ///   <para>The created tensor span has a single dimension that is the same length as <paramref name="array" />.</para>
+        /// </remarks>
+        public ReadOnlyTensorSpan(T[]? array)
+        {
+            _shape = TensorShape.Create(array);
+            _reference = ref (array is not null)
+                       ? ref MemoryMarshal.GetArrayDataReference(array)
+                       : ref Unsafe.NullRef<T>();
+        }
+
+        /// <summary>Creates a new tensor over the portion of the target array using the specified lengths.</summary>
+        /// <param name="array">The target array.</param>
+        /// <param name="lengths">The lengths of the dimensions. If an empty span is provided, the created tensor will have a single dimension that is the same length as <paramref name="array" />.</param>
+        /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   Thrown when one of the following conditions is met:
+        ///   * <paramref name="array" /> is null and <paramref name="lengths" /> is not empty
+        ///   * <paramref name="lengths" /> is not empty and contains an element that is either zero or negative
+        ///   * <paramref name="lengths" /> is not empty and has a flattened length greater than <paramref name="array" />.Length
+        /// </exception>
+        public ReadOnlyTensorSpan(T[]? array, scoped ReadOnlySpan<nint> lengths)
+        {
+            _shape = TensorShape.Create(array, lengths);
+            _reference = ref (array is not null)
+                       ? ref MemoryMarshal.GetArrayDataReference(array)
+                       : ref Unsafe.NullRef<T>();
+        }
+
+        /// <summary>Creates a new tensor over the portion of the target array beginning at the specified start index and using the specified lengths and strides.</summary>
+        /// <param name="array">The target array.</param>
+        /// <param name="lengths">The lengths of the dimensions. If an empty span is provided, the created tensor will have a single dimension that is the same length as <paramref name="array" />.</param>
+        /// <param name="strides">The strides of each dimension. If an empty span is provided, then strides will be automatically calculated from <paramref name="lengths" />.</param>
+        /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   Thrown when one of the following conditions is met:
+        ///   * <paramref name="array" /> is null and <paramref name="lengths" /> or <paramref name="strides" /> is not empty
+        ///   * <paramref name="lengths" /> is not empty and contains an element that is either zero or negative
+        ///   * <paramref name="lengths" /> is not empty and has a flattened length greater than <paramref name="array" />.Length
+        ///   * <paramref name="strides" /> is not empty and has a length different from <paramref name="lengths"/>
+        ///   * <paramref name="strides" /> is not empty and contains an element that is negative
+        ///   * <paramref name="strides" /> is not empty and contains an element that is zero in a non leading position
+        /// </exception>
+        public ReadOnlyTensorSpan(T[]? array, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            _shape = TensorShape.Create(array, lengths, strides);
+            _reference = ref (array is not null)
+                       ? ref MemoryMarshal.GetArrayDataReference(array)
+                       : ref Unsafe.NullRef<T>();
+        }
+
+        /// <summary>Creates a new tensor over the portion of the target array beginning at the specified start index and using the specified lengths and strides.</summary>
+        /// <param name="array">The target array.</param>
+        /// <param name="start">The index at which to begin the tensor.</param>
+        /// <param name="lengths">The lengths of the dimensions. If an empty span is provided, the created tensor will have a single dimension that is the same length as <paramref name="array" />.</param>
+        /// <param name="strides">The strides of each dimension. If an empty span is provided, then strides will be automatically calculated from <paramref name="lengths" />.</param>
+        /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   Thrown when one of the following conditions is met:
+        ///   * <paramref name="array" /> is null and <paramref name="lengths" /> or <paramref name="strides" /> is not empty
+        ///   * <paramref name="start" /> is not in range of <paramref name="array" />
+        ///   * <paramref name="lengths" /> is not empty and contains an element that is either zero or negative
+        ///   * <paramref name="lengths" /> is not empty and has a flattened length greater than <paramref name="array" />.Length
+        ///   * <paramref name="strides" /> is not empty and has a length different from <paramref name="lengths"/>
+        ///   * <paramref name="strides" /> is not empty and contains an element that is negative
+        ///   * <paramref name="strides" /> is not empty and contains an element that is zero in a non leading position
+        /// </exception>
+        public ReadOnlyTensorSpan(T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            _shape = TensorShape.Create(array, start, lengths, strides);
+            _reference = ref (array is not null)
+                       ? ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (uint)start)
+                       : ref Unsafe.NullRef<T>();
+        }
+
+        /// <summary>Creates a new tensor span over the entirety of the target span.</summary>
+        /// <param name="span">The target span.</param>
+        /// <remarks>The created tensor span has a single dimension that is the same length as <paramref name="span" />.</remarks>
+        public ReadOnlyTensorSpan(ReadOnlySpan<T> span)
+        {
+            ref T reference = ref MemoryMarshal.GetReference(span);
+            _shape = TensorShape.Create(ref reference, span.Length);
+            _reference = ref reference;
+        }
+
+        /// <summary>Creates a new tensor span over the target span using the specified lengths.</summary>
+        /// <param name="span">The target span.</param>
+        /// <param name="lengths">The lengths of the dimensions. If an empty span is provided, the created tensor span will have a single dimension that is the same length as <paramref name="span" />.</param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   Thrown when one of the following conditions is met:
+        ///   * <paramref name="lengths" /> is not empty and contains an element that is either zero or negative
+        ///   * <paramref name="lengths" /> is not empty and has a flattened length greater than <paramref name="span" />.Length
+        /// </exception>
+        public ReadOnlyTensorSpan(ReadOnlySpan<T> span, scoped ReadOnlySpan<nint> lengths)
+        {
+            ref T reference = ref MemoryMarshal.GetReference(span);
+            _shape = TensorShape.Create(ref reference, span.Length, lengths);
+            _reference = ref reference;
+        }
+
+        /// <summary>Creates a new tensor span over the target span using the specified lengths and strides.</summary>
+        /// <param name="span">The target span.</param>
+        /// <param name="lengths">The lengths of the dimensions. If an empty span is provided, the created tensor span will have a single dimension that is the same length as <paramref name="span" />.</param>
+        /// <param name="strides">The strides of each dimension. If an empty span is provided, then strides will be automatically calculated from <paramref name="lengths" />.</param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   Thrown when one of the following conditions is met:
+        ///   * <paramref name="lengths" /> is not empty and contains an element that is either zero or negative
+        ///   * <paramref name="lengths" /> is not empty and has a flattened length greater than <paramref name="span" />.Length
+        ///   * <paramref name="strides" /> is not empty and has a length different from <paramref name="lengths"/>
+        ///   * <paramref name="strides" /> is not empty and contains an element that is negative
+        ///   * <paramref name="strides" /> is not empty and contains an element that is zero in a non leading position
+        /// </exception>
+        public ReadOnlyTensorSpan(ReadOnlySpan<T> span, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            ref T reference = ref MemoryMarshal.GetReference(span);
+            _shape = TensorShape.Create(ref reference, span.Length, lengths, strides);
+            _reference = ref reference;
+        }
+
+        /// <summary>Creates a new tensor span over the entirety of the target array.</summary>
+        /// <param name="array">The target array.</param>
+        /// <remarks>
+        ///   <para>Returns default when <paramref name="array"/> is null.</para>
+        ///   <para>The created tensor span has a single dimension that is the same length as <paramref name="array" />.</para>
+        /// </remarks>
+        public ReadOnlyTensorSpan(Array? array)
+        {
+            _shape = TensorShape.Create(array);
+            _reference = ref (array is not null)
+                       ? ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array))
+                       : ref Unsafe.NullRef<T>();
+        }
+
+        /// <summary>Creates a new tensor span over the portion of the target array beginning at the specified start index and using the specified lengths and strides.</summary>
+        /// <param name="array">The target array.</param>
+        /// <param name="start">The index at which to begin the tensor span.</param>
+        /// <param name="lengths">The lengths of the dimensions. If an empty span is provided, the created tensor span will have a single dimension that is the same length as <paramref name="array" />.</param>
+        /// <param name="strides">The strides of each dimension. If an empty span is provided, then strides will be automatically calculated from <paramref name="lengths" />.</param>
+        /// <remarks>
+        ///   <para>Returns default when <paramref name="array"/> is null.</para>
+        ///   <para></para>
+        /// </remarks>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   Thrown when one of the following conditions is met:
+        ///   * <paramref name="array" /> is null and <paramref name="lengths" /> or <paramref name="strides" /> is not empty
+        ///   * <paramref name="start" /> is not in range of <paramref name="array" />
+        ///   * <paramref name="lengths" /> is not empty and contains an element that is either zero or negative
+        ///   * <paramref name="lengths" /> is not empty and has a flattened length greater than <paramref name="array" />.Length
+        ///   * <paramref name="strides" /> is not empty and has a length different from <paramref name="lengths"/>
+        ///   * <paramref name="strides" /> is not empty and contains an element that is negative
+        ///   * <paramref name="strides" /> is not empty and contains an element that is zero in a non leading position
+        /// </exception>
+        public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan<int> start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            _shape = TensorShape.Create(array, start, lengths, strides, out nint linearOffset);
+            _reference = ref (array is not null)
+                       ? ref Unsafe.Add(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), linearOffset)
+                       : ref Unsafe.NullRef<T>();
+        }
+
+        /// <summary>Creates a new tensor span over the target unmanaged buffer.</summary>
+        /// <param name="data">The pointer to the start of the target unmanaged buffer.</param>
+        /// <param name="dataLength">The number of elements the target unmanaged buffer contains.</param>
+        /// <remarks>Returns default when <paramref name="data" /> is null.</remarks>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="data" /> is <c>null</c> and <paramref name="dataLength" /> is not zero</exception>
+
+        [CLSCompliant(false)]
+        public unsafe ReadOnlyTensorSpan(T* data, nint dataLength)
+        {
+            _shape = TensorShape.Create(data, dataLength);
+            _reference = ref Unsafe.AsRef<T>(data);
+        }
+
+        /// <summary>Creates a new tensor span over the target unmanaged buffer using the specified lengths.</summary>
+        /// <param name="data">The pointer to the start of the target unmanaged buffer.</param>
+        /// <param name="dataLength">The number of elements the target unmanaged buffer contains.</param>
+        /// <param name="lengths">The lengths of the dimensions. If an empty span is provided, the created tensor span will have a single dimension that is the same length as <paramref name="dataLength" />.</param>
+        /// <remarks>Returns default when <paramref name="data" /> is null.</remarks>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   Thrown when one of the following conditions is met:
+        ///   * <paramref name="data" /> is <c>null</c> and <paramref name="dataLength" /> is not zero
+        ///   * <paramref name="data" /> is null and <paramref name="lengths" />
+        ///   * <paramref name="lengths" /> is not empty and contains an element that is either zero or negative
+        ///   * <paramref name="lengths" /> is not empty and has a flattened length greater than <paramref name="dataLength" />
+        /// </exception>
+        [CLSCompliant(false)]
+        public unsafe ReadOnlyTensorSpan(T* data, nint dataLength, scoped ReadOnlySpan<nint> lengths)
+        {
+            _shape = TensorShape.Create(data, dataLength, lengths);
+            _reference = ref Unsafe.AsRef<T>(data);
+        }
+
+        /// <summary>Creates a new tensor span over the target unmanaged buffer using the specified lengths and strides.</summary>
+        /// <param name="data">The pointer to the start of the target unmanaged buffer.</param>
+        /// <param name="dataLength">The number of elements the target unmanaged buffer contains.</param>
+        /// <param name="lengths">The lengths of the dimensions. If an empty span is provided, the created tensor span will have a single dimension that is the same length as <paramref name="dataLength" />.</param>
+        /// <param name="strides">The strides of each dimension. If an empty span is provided, then strides will be automatically calculated from <paramref name="lengths" />.</param>
+        /// <remarks>Returns default when <paramref name="data" /> is null.</remarks>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///   Thrown when one of the following conditions is met:
+        ///   * <paramref name="data" /> is <c>null</c> and <paramref name="dataLength" /> is not zero
+        ///   * <paramref name="data" /> is null and <paramref name="lengths" /> or <paramref name="strides" /> is not empty
+        ///   * <paramref name="lengths" /> is not empty and contains an element that is either zero or negative
+        ///   * <paramref name="lengths" /> is not empty and has a flattened length greater than <paramref name="dataLength" />
+        ///   * <paramref name="strides" /> is not empty and has a length different from <paramref name="lengths"/>
+        ///   * <paramref name="strides" /> is not empty and contains an element that is negative
+        ///   * <paramref name="strides" /> is not empty and contains an element that is zero in a non leading position
+        /// </exception>
+        [CLSCompliant(false)]
+        public unsafe ReadOnlyTensorSpan(T* data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            _shape = TensorShape.Create(data, dataLength, lengths, strides);
+            _reference = ref Unsafe.AsRef<T>(data);
+        }
+
+        // Constructor for internal use only. It is not safe to expose publicly.
+        internal ReadOnlyTensorSpan(ref T data, nint dataLength)
+        {
+            _shape = TensorShape.Create(ref data, dataLength);
+            _reference = ref data;
+        }
+
+        internal ReadOnlyTensorSpan(ref T data, nint dataLength, scoped ReadOnlySpan<nint> lengths)
+        {
+            _shape = TensorShape.Create(ref data, dataLength, lengths);
+            _reference = ref data;
+        }
+
+        internal ReadOnlyTensorSpan(ref T data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            _shape = TensorShape.Create(ref data, dataLength, lengths, strides);
+            _reference = ref data;
+        }
+
+        internal ReadOnlyTensorSpan(ref T data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, scoped ReadOnlySpan<int> linearRankOrder)
+        {
+            _shape = TensorShape.Create(ref data, dataLength, lengths, strides, linearRankOrder);
+            _reference = ref data;
+        }
+
+        internal ReadOnlyTensorSpan(ref T reference, scoped in TensorShape shape)
+        {
+            _reference = ref reference;
+            _shape = shape;
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.this[ReadOnlySpan{nint}]" />
+        public ref readonly T this[params scoped ReadOnlySpan<nint> indexes]
+        {
+            get => ref Unsafe.Add(ref _reference, _shape.GetLinearOffset<TensorShape.GetOffsetAndLengthForNInt, nint>(indexes));
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.this[ReadOnlySpan{NIndex}]" />
+        public ref readonly T this[params scoped ReadOnlySpan<NIndex> indexes]
+        {
+            get => ref Unsafe.Add(ref _reference, _shape.GetLinearOffset<TensorShape.GetOffsetAndLengthForNIndex, NIndex>(indexes));
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.this[ReadOnlySpan{NRange}]" />
+        public ReadOnlyTensorSpan<T> this[params scoped ReadOnlySpan<NRange> ranges]
+        {
+            get => Slice(ranges);
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor.FlattenedLength" />
+        public nint FlattenedLength => _shape.FlattenedLength;
+
+        internal bool IsContiguousAndDense => _shape.IsContiguousAndDense;
+
+        /// <inheritdoc cref="IReadOnlyTensor.IsEmpty" />
+        public bool IsEmpty => _shape.IsEmpty;
+
+        /// <inheritdoc cref="IReadOnlyTensor.Lengths" />
+        [UnscopedRef]
+        public ReadOnlySpan<nint> Lengths => _shape.Lengths;
+
+        /// <inheritdoc cref="IReadOnlyTensor.Rank" />
+        public int Rank => Lengths.Length;
+
+        /// <inheritdoc cref="IReadOnlyTensor.Strides" />
+        [UnscopedRef]
+        public ReadOnlySpan<nint> Strides => _shape.Strides;
+
+        /// <summary>Returns a value that indicates whether two tensor spans are equal.</summary>
+        /// <param name="left">The first tensor span to compare.</param>
+        /// <param name="right">The second tensor span to compare.</param>
+        /// <returns><c>true</c> if the two tensor span are equal; otherwise, <c>false</c>.</returns>
+        /// <remarks>Two tensor span are equal if they have the same length and the corresponding elements of <paramref name="left" /> and <paramref name="right" /> point to the same memory. Note that the test for equality does not attempt to determine whether the contents are equal.</remarks>
+        public static bool operator ==(in ReadOnlyTensorSpan<T> left, in ReadOnlyTensorSpan<T> right)
+            => Unsafe.AreSame(ref left._reference, ref right._reference)
+            && left._shape == right._shape;
+
+        /// <summary>Returns a value that indicates whether two tensor spans are not equal.</summary>
+        /// <param name="left">The first tensor span to compare.</param>
+        /// <param name="right">The second tensor span to compare.</param>
+        /// <returns><c>true</c> if the two tensor span are not equal; otherwise, <c>false</c>.</returns>
+        /// <remarks>Two tensor span are not equal if they have the different lengths or if the corresponding elements of <paramref name="left" /> and <paramref name="right" /> do not point to the same memory. Note that the test for equality does not attempt to determine whether the contents are not equal.</remarks>
+        public static bool operator !=(in ReadOnlyTensorSpan<T> left, in ReadOnlyTensorSpan<T> right) => !(left == right);
+
+        /// <summary>Defines an implicit conversion of an array to a readonly tensor span.</summary>
+        /// <param name="array">The array to convert to a readonly tensor span.</param>
+        /// <returns>The readonly tensor span that corresponds to <paramref name="array" />.</returns>
+        public static implicit operator ReadOnlyTensorSpan<T>(T[]? array) => new ReadOnlyTensorSpan<T>(array);
+
+        /// <summary>Casts a tensor span of <typeparamref name="TDerived" /> to a tensor span of <typeparamref name="T" />.</summary>
+        /// <typeparam name="TDerived">The element type of the source tensor span, which must be derived from <typeparamref name="T" />.</typeparam>
+        /// <param name="items">The source tensor span. No copy is made.</param>
+        /// <returns>A tensor span with elements cast to the new type.</returns>
+        /// <remarks>This method uses a covariant cast, producing a tensor span that shares the same memory as the source. The relationships expressed in the type constraints ensure that the cast is a safe operation.</remarks>
+        public static ReadOnlyTensorSpan<T> CastUp<TDerived>(in ReadOnlyTensorSpan<TDerived> items)
+            where TDerived : class?, T
+        {
+            return new ReadOnlyTensorSpan<T>(
+                ref Unsafe.As<TDerived, T>(ref items._reference),
+                items._shape
+            );
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.CopyTo(in TensorSpan{T})" />
+        public void CopyTo(scoped in TensorSpan<T> destination)
+        {
+            if (!TryCopyTo(destination))
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+        }
+
+        /// <summary>Calls to this method are not supported.</summary>
+        /// <param name="obj">Not supported.</param>
+        /// <returns>Calls to this method are not supported.</returns>
+        /// <exception cref="NotSupportedException">Calls to this method are not supported.</exception>
+        /// <remarks>This method is not supported as tensor spans cannot be boxed. To compare two tensor spans, use operator ==.</remarks>
+        [Obsolete("Equals() on ReadOnlyTensorSpan will always throw an exception. Use the equality operator instead.")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override bool Equals(object? obj) =>
+            throw new NotSupportedException(SR.NotSupported_CannotCallEqualsOnSpan);
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.FlattenTo(Span{T})" />
+        public void FlattenTo(scoped Span<T> destination)
+        {
+            if (!TryFlattenTo(destination))
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+        }
+
+        /// <summary>Gets an enumerator for the readonly tensor span.</summary>
+        public Enumerator GetEnumerator() => new Enumerator(this);
+
+        /// <summary>Calls to this method are not supported.</summary>
+        /// <returns>Calls to this method are not supported.</returns>
+        /// <exception cref="NotSupportedException">Calls to this method are not supported.</exception>
+        /// <remarks>This method is not supported as tensor spans cannot be boxed.</remarks>
+        [Obsolete("GetHashCode() on ReadOnlyTensorSpan will always throw an exception.")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override int GetHashCode() =>
+            throw new NotSupportedException(SR.NotSupported_CannotCallGetHashCodeOnSpan);
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.GetPinnableReference()" />
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public ref readonly T GetPinnableReference()
+        {
+            // Ensure that the native code has just one forward branch that is predicted-not-taken.
+            ref T ret = ref Unsafe.NullRef<T>();
+            if (_shape.FlattenedLength != 0) ret = ref _reference;
+            return ref ret;
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Slice(ReadOnlySpan{nint})" />
+        public ReadOnlyTensorSpan<T> Slice(params scoped ReadOnlySpan<nint> startIndexes)
+        {
+            TensorShape shape = _shape.Slice<TensorShape.GetOffsetAndLengthForNInt, nint>(startIndexes, out nint linearOffset);
+            return new ReadOnlyTensorSpan<T>(
+                ref Unsafe.Add(ref _reference, linearOffset),
+                shape
+            );
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Slice(ReadOnlySpan{NIndex})" />
+        public ReadOnlyTensorSpan<T> Slice(params scoped ReadOnlySpan<NIndex> startIndexes)
+        {
+            TensorShape shape = _shape.Slice<TensorShape.GetOffsetAndLengthForNIndex, NIndex>(startIndexes, out nint linearOffset);
+            return new ReadOnlyTensorSpan<T>(
+                ref Unsafe.Add(ref _reference, linearOffset),
+                shape
+            );
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Slice(ReadOnlySpan{NRange})" />
+        public ReadOnlyTensorSpan<T> Slice(params scoped ReadOnlySpan<NRange> ranges)
+        {
+            TensorShape shape = _shape.Slice<TensorShape.GetOffsetAndLengthForNRange, NRange>(ranges, out nint linearOffset);
+            return new ReadOnlyTensorSpan<T>(
+                ref Unsafe.Add(ref _reference, linearOffset),
+                shape
+            );
+        }
+
+        /// <summary>Returns the string representation of the tensor span.</summary>
+        /// <returns>The string representation of the tensor span.</returns>
+        public override string ToString() => $"System.Numerics.Tensors.ReadOnlyTensorSpan<{typeof(T).Name}>[{_shape}]";
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.TryCopyTo(in TensorSpan{T})" />
+        public bool TryCopyTo(scoped in TensorSpan<T> destination)
+        {
+            if (TensorShape.AreCompatible(destination._shape, _shape, false))
+            {
+                TensorOperation.Invoke<TensorOperation.CopyTo<T>, T, T>(this, destination);
+                return true;
+            }
+            return false;
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.TryFlattenTo(Span{T})" />
+        public bool TryFlattenTo(scoped Span<T> destination)
+        {
+            if (_shape.FlattenedLength <= destination.Length)
+            {
+                TensorOperation.Invoke<TensorOperation.CopyTo<T>, T, T>(this, destination);
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>Enumerates the elements of a tensor span.</summary>
+        public ref struct Enumerator : IEnumerator<T>
+        {
+            private readonly ReadOnlyTensorSpan<T> _span;
+            private nint[] _indexes;
+            private nint _linearOffset;
+            private nint _itemsEnumerated;
+
+            internal Enumerator(ReadOnlyTensorSpan<T> span)
+            {
+                _span = span;
+                _indexes = new nint[span.Rank];
+
+                _indexes[^1] = -1;
+
+                _linearOffset = 0 - (!span.IsEmpty ? span.Strides[^1] : 0);
+                _itemsEnumerated = 0;
+            }
+
+            /// <summary>Gets the element at the current position of the enumerator.</summary>
+            public readonly ref readonly T Current => ref Unsafe.Add(ref _span._reference, _linearOffset);
+
+            /// <summary>Advances the enumerator to the next element of the tensor span.</summary>
+            public bool MoveNext()
+            {
+                if (_itemsEnumerated == _span._shape.FlattenedLength)
+                {
+                    return false;
+                }
+
+                _linearOffset = _span._shape.AdjustToNextIndex(_span._shape, _linearOffset, _indexes);
+
+                _itemsEnumerated++;
+                return true;
+            }
+
+            /// <summary>Sets the enumerator to its initial position, which is before the first element in the tensor span.</summary>
+            public void Reset()
+            {
+                Array.Clear(_indexes);
+                _indexes[^1] = -1;
+
+                _linearOffset = 0 - (!_span.IsEmpty ? _span.Strides[^1] : 0);
+                _itemsEnumerated = 0;
+            }
+
+            //
+            // IDisposable
+            //
+
+            void IDisposable.Dispose() { }
+
+            //
+            // IEnumerator
+            //
+
+            readonly object? IEnumerator.Current => Current;
+
+            //
+            // IEnumerator<T>
+            //
+
+            readonly T IEnumerator<T>.Current => Current;
+        }
+    }
+}
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
deleted file mode 100644
index 29b48f4a613e03..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs
+++ /dev/null
@@ -1,216 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Runtime.InteropServices;
-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.
-
-namespace System.Numerics.Tensors
-{
-    /// <summary>
-    /// Provides methods for creating tensors.
-    /// </summary>
-    public static partial class Tensor
-    {
-        /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with the default value of T. If <paramref name="pinned"/> is true, the memory will be pinned.
-        /// </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>
-        public static Tensor<T> Create<T>(scoped ReadOnlySpan<nint> lengths, bool pinned = false)
-        {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
-            return Create(values, lengths, [], pinned);
-        }
-
-        /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with the default value of T. If <paramref name="pinned"/> is true, the memory will be pinned.
-        /// </summary>
-        /// <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>
-        public static Tensor<T> Create<T>(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned = false)
-        {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
-            return Create(values, lengths, strides, pinned);
-        }
-
-        /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> from the provided <paramref name="values"/>. If the product of the
-        /// <paramref name="lengths"/> does not equal the length of the <paramref name="values"/> array, an exception will be thrown.
-        /// </summary>
-        /// <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="pinned">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, bool pinned = false)
-            => Create(values, lengths, [], pinned);
-
-        /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> from the provided <paramref name="values"/>. If the product of the
-        /// <paramref name="lengths"/> does not equal the length of the <paramref name="values"/> array, an exception will be thrown.
-        /// </summary>
-        /// <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="pinned">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, bool pinned = false)
-        {
-            return new Tensor<T>(values, lengths, strides, memoryOffset: 0, pinned);
-        }
-
-        /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with the data from <paramref name="values"/>.
-        /// </summary>
-        /// <param name="values">A <see cref="IEnumerable{T}"/> with the data to use for the initialization.</param>
-        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
-        /// <param name="pinned">A <see cref="bool"/> indicating whether the <paramref name="values"/> were pinned or not.</param>
-
-        public static Tensor<T> Create<T>(IEnumerable<T> values, scoped ReadOnlySpan<nint> lengths, bool pinned = false)
-        {
-            T[] data = values.ToArray();
-            return new Tensor<T>(data, lengths.IsEmpty ? [data.Length] : lengths, memoryOffset: 0, pinned);
-        }
-
-        /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with the data from <paramref name="values"/>.
-        /// </summary>
-        /// <param name="values">A <see cref="IEnumerable{T}"/> with the data to use for the initialization.</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="pinned">A <see cref="bool"/> indicating whether the <paramref name="values"/> were pinned or not.</param>
-        public static Tensor<T> Create<T>(IEnumerable<T> values, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned = false)
-        {
-            T[] data = values.ToArray();
-            return new Tensor<T>(data, lengths.IsEmpty ? [data.Length] : lengths, strides, memoryOffset: 0, pinned);
-        }
-
-        #region Normal
-        /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with random data in a gaussian normal distribution.
-        /// </summary>
-        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
-        public static Tensor<T> CreateAndFillGaussianNormalDistribution<T>(params scoped ReadOnlySpan<nint> lengths)
-            where T : IFloatingPoint<T>
-        {
-            return CreateAndFillGaussianNormalDistribution<T>(Random.Shared, lengths);
-        }
-
-        /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with random data in a gaussian normal distribution.
-        /// </summary>
-        /// <param name="random"></param>
-        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
-        public static Tensor<T> CreateAndFillGaussianNormalDistribution<T>(Random random, params scoped ReadOnlySpan<nint> lengths)
-            where T : IFloatingPoint<T>
-        {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = new T[linearLength];
-            GaussianDistribution<T>(values, linearLength, random);
-            return new Tensor<T>(values, lengths, memoryOffset: 0, isPinned: false);
-        }
-
-        private static void GaussianDistribution<T>(in Span<T> values, nint linearLength, Random random)
-             where T : IFloatingPoint<T>
-        {
-            for (int i = 0; i < linearLength; i++)
-            {
-                double u1 = 1.0 - random.NextDouble();
-                double u2 = 1.0 - random.NextDouble();
-                values[i] = T.CreateChecked(Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2));
-            }
-        }
-        #endregion
-
-
-        /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with random data uniformly distributed.
-        /// </summary>
-        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
-        public static Tensor<T> CreateAndFillUniformDistribution<T>(params scoped ReadOnlySpan<nint> lengths)
-            where T : IFloatingPoint<T>
-        {
-            return CreateAndFillUniformDistribution<T>(Random.Shared, lengths);
-        }
-
-        /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with random data uniformly distributed.
-        /// </summary>
-        /// <param name="random"></param>
-        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
-        public static Tensor<T> CreateAndFillUniformDistribution<T>(Random random, params scoped ReadOnlySpan<nint> lengths)
-            where T : IFloatingPoint<T>
-        {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = new T[linearLength];
-            for (int i = 0; i < values.Length; i++)
-                values[i] = T.CreateChecked(random.NextDouble());
-
-            return new Tensor<T>(values, lengths, memoryOffset: 0, isPinned: false);
-        }
-
-        /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and does not initialize it. If <paramref name="pinned"/> is true, the memory will be pinned.
-        /// </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>
-        public static Tensor<T> CreateUninitialized<T>(scoped ReadOnlySpan<nint> lengths, bool pinned = false)
-            => 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.
-        /// </summary>
-        /// <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>
-        public static Tensor<T> CreateUninitialized<T>(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned = false)
-        {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, pinned);
-            return new Tensor<T>(values, lengths, strides, memoryOffset: 0, pinned);
-        }
-
-        /// <summary>
-        /// Fills the given <see cref="TensorSpan{T}"/> with random data in a Gaussian normal distribution. <see cref="System.Random"/>
-        /// can optionally be provided for seeding.
-        /// </summary>
-        /// <typeparam name="T">The element type.</typeparam>
-        /// <param name="destination">The destination <see cref="TensorSpan{T}"/> where the data will be stored.</param>
-        /// <param name="random"><see cref="System.Random"/> to provide random seeding. Defaults to <see cref="Random.Shared"/> if not provided.</param>
-        /// <returns></returns>
-        public static ref readonly TensorSpan<T> FillGaussianNormalDistribution<T>(in TensorSpan<T> destination, Random? random = null) where T : IFloatingPoint<T>
-        {
-            Span<T> span = MemoryMarshal.CreateSpan<T>(ref destination._reference, (int)destination._shape._memoryLength);
-
-            GaussianDistribution<T>(span, destination._shape._memoryLength, random ?? Random.Shared);
-
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Fills the given <see cref="TensorSpan{T}"/> with random data in a uniform distribution. <see cref="System.Random"/>
-        /// can optionally be provided for seeding.
-        /// </summary>
-        /// <typeparam name="T">The element type.</typeparam>
-        /// <param name="destination">The destination <see cref="TensorSpan{T}"/> where the data will be stored.</param>
-        /// <param name="random"><see cref="System.Random"/> to provide random seeding. Defaults to <see cref="Random.Shared"/> if not provided.</param>
-        /// <returns></returns>
-        public static ref readonly TensorSpan<T> FillUniformDistribution<T>(in TensorSpan<T> destination, Random? random = null) where T : IFloatingPoint<T>
-        {
-            Span<T> span = MemoryMarshal.CreateSpan<T>(ref destination._reference, (int)destination._shape._memoryLength);
-            random ??= Random.Shared;
-            for (int i = 0; i < span.Length; i++)
-                span[i] = T.CreateChecked(random.NextDouble());
-
-            return ref destination;
-        }
-    }
-}
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 4878350449c319..aaf9612ae0a0b3 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
@@ -1,751 +1,5624 @@
 // 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;
 using System.Collections.Generic;
-using System.ComponentModel;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Reflection.Metadata.Ecma335;
+using System.Linq;
 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.
 
 namespace System.Numerics.Tensors
 {
-    /// <summary>
-    /// Represents a tensor.
-    /// </summary>
+    /// <summary>Provides methods for tensor operations.</summary>
     [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
-    public sealed class Tensor<T> : ITensor, ITensor<Tensor<T>, T>
+    public static partial class Tensor
     {
-        /// <summary>A byref or a native ptr.</summary>
-        internal readonly T[] _values;
-        /// <summary>The number of elements this Tensor contains.</summary>
-        internal readonly nint _flattenedLength;
-        /// <summary>The lengths of each dimension.</summary>
-        internal readonly nint[] _lengths;
-        /// <summary>The strides representing the memory offsets for each dimension.</summary>
-        internal readonly nint[] _strides;
-        /// <summary>If the backing memory is permanently pinned (so not just using a fixed statement).</summary>
-        internal readonly bool _isPinned;
-        /// <summary>The offset of the first element in the backing memory.</summary>
-        internal readonly int _memoryOffset;
-
-        /// <summary>
-        /// Creates a new empty Tensor.
-        /// </summary>
-        internal Tensor()
-        {
-            _flattenedLength = 0;
-            _values = [];
-            _lengths = [];
-            _strides = [];
-            _memoryOffset = 0;
-        }
+        #region AsTensorSpan
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[])" />
+        public static ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan<T>(this T[]? array)
+            => new ReadOnlyTensorSpan<T>(array);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal Tensor(T[]? values, ReadOnlySpan<nint> lengths, int memoryOffset, bool isPinned = false) : this(values, lengths, Array.Empty<nint>(), memoryOffset, isPinned) { }
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[], ReadOnlySpan{nint})" />
+        public static ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan<T>(this T[]? array, scoped ReadOnlySpan<nint> lengths)
+            => new ReadOnlyTensorSpan<T>(array, lengths);
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal Tensor(T[]? values, ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides, int memoryOffset, bool isPinned = false)
-        {
-            if (values == null)
-            {
-                if (_flattenedLength != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-                _flattenedLength = 0;
-                _values = [];
-                _lengths = [];
-                _strides = [];
-                _memoryOffset = memoryOffset;
-                return; // returns default
-            }
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[], ReadOnlySpan{nint}, ReadOnlySpan{nint})" />
+        public static ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan<T>(this T[]? array, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+            => new ReadOnlyTensorSpan<T>(array, lengths, strides);
 
-            _lengths = lengths.IsEmpty ? [values.Length] : lengths.ToArray();
-            _memoryOffset = memoryOffset;
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[], int, ReadOnlySpan{nint}, ReadOnlySpan{nint})" />
+        public static ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan<T>(this T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+            => new ReadOnlyTensorSpan<T>(array, start, lengths, strides);
 
-            if (_memoryOffset < 0 || (_memoryOffset >= values.Length && values.Length != 0 ))
-                ThrowHelper.ThrowIndexOutOfRangeException();
+        /// <inheritdoc cref="TensorSpan{T}.TensorSpan(T[])" />
+        public static TensorSpan<T> AsTensorSpan<T>(this T[]? array)
+            => new TensorSpan<T>(array);
 
-            _flattenedLength = TensorSpanHelpers.CalculateTotalLength(_lengths);
-            _strides = strides.IsEmpty ? TensorSpanHelpers.CalculateStrides(_lengths, _flattenedLength) : strides.ToArray();
-            TensorSpanHelpers.ValidateStrides(_strides, _lengths);
-            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(_strides, _lengths);
+        /// <inheritdoc cref="TensorSpan{T}.TensorSpan(T[], ReadOnlySpan{nint})" />
+        public static TensorSpan<T> AsTensorSpan<T>(this T[]? array, scoped ReadOnlySpan<nint> lengths)
+            => new TensorSpan<T>(array, lengths);
 
-            if (Environment.Is64BitProcess)
-            {
-                // See comment in Span<T>.Slice for how this works.
-                if ((ulong)(uint)maxElements >= (ulong)(uint)(values.Length - memoryOffset) && values.Length != 0)
-                    ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
-            }
-            else
-            {
-                if (((uint)maxElements >= (uint)(values.Length - memoryOffset)) && values.Length != 0)
-                    ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
-            }
+        /// <inheritdoc cref="TensorSpan{T}.TensorSpan(T[], ReadOnlySpan{nint} , ReadOnlySpan{nint})" />
+        public static TensorSpan<T> AsTensorSpan<T>(this T[]? array, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+            => new TensorSpan<T>(array, lengths, strides);
 
-            _values = values;
-            _isPinned = isPinned;
-        }
+        /// <inheritdoc cref="TensorSpan{T}.TensorSpan(T[], int, ReadOnlySpan{nint}, ReadOnlySpan{nint})" />
+        public static TensorSpan<T> AsTensorSpan<T>(this T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides) => new TensorSpan<T>(array, start, lengths, strides);
+        #endregion
 
+        #region Broadcast
         /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with the default value of T. If <paramref name="pinned"/> is true, the memory will be pinned.
+        /// Broadcast the data from <paramref name="source"/> to the smallest broadcastable shape compatible with <paramref name="lengthsSource"/>. Creates a new <see cref="Tensor{T}"/> and allocates new memory.
         /// </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)
+        /// <param name="source">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="lengthsSource">Other <see cref="Tensor{T}"/> to make shapes broadcastable.</param>
+        public static Tensor<T> Broadcast<T>(scoped in ReadOnlyTensorSpan<T> source, scoped in ReadOnlyTensorSpan<T> lengthsSource)
         {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
-            return new Tensor<T>(values, lengths.ToArray(), memoryOffset: 0, pinned);
+            return Broadcast(source, lengthsSource.Lengths);
         }
 
         /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with the default value of T. If <paramref name="pinned"/> is true, the memory will be pinned.
+        /// Broadcast the data from <paramref name="source"/> to the new shape <paramref name="lengths"/>. Creates a new <see cref="Tensor{T}"/> and allocates new memory.
+        /// If the shape of the <paramref name="source"/> is not compatible with the new shape, an exception is thrown.
         /// </summary>
-        /// <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)
+        /// <param name="source">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="lengths"><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>(scoped in ReadOnlyTensorSpan<T> source, scoped ReadOnlySpan<nint> lengths)
         {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
-            return new Tensor<T>(values, lengths.ToArray(), strides.ToArray(), memoryOffset: 0, pinned);
+            TensorOperation.ValidateCompatibility<T>(source, lengths);
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(lengths);
+            TensorOperation.Invoke<TensorOperation.CopyTo<T>, T, T>(source, destination);
+            return destination;
         }
+        #endregion
 
+        #region BroadcastTo
         /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and does not initialize it. If <paramref name="pinned"/> is true, the memory will be pinned.
+        /// Broadcast the data from <paramref name="source"/> to <paramref name="destination"/>.
         /// </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)
+        /// <param name="source">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static void BroadcastTo<T>(this Tensor<T> source, in TensorSpan<T> destination)
         {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, pinned);
-            return new Tensor<T>(values, lengths.ToArray(), memoryOffset: 0, pinned);
+            TensorOperation.ValidateCompatibility<T, T>(source, destination);
+            TensorOperation.Invoke<TensorOperation.CopyTo<T>, T, T>(source, destination);
         }
 
         /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and does not initialize it. If <paramref name="pinned"/> is true, the memory will be pinned.
+        /// Broadcast the data from <paramref name="source"/> to <paramref name="destination"/>.
         /// </summary>
-        /// <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)
+        /// <param name="source">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="destination">Other <see cref="TensorSpan{T}"/> to make shapes broadcastable.</param>
+        public static void BroadcastTo<T>(in this TensorSpan<T> source, in TensorSpan<T> destination)
         {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, pinned);
-            return new Tensor<T>(values, lengths.ToArray(), strides.ToArray(), memoryOffset: 0, pinned);
+            TensorOperation.ValidateCompatibility<T, T>(source, destination);
+            TensorOperation.Invoke<TensorOperation.CopyTo<T>, T, T>(source, destination);
         }
 
-        // ITensor
         /// <summary>
-        /// The Empty Tensor.
+        /// Broadcast the data from <paramref name="source"/> to <paramref name="destination"/>.
         /// </summary>
-        public static Tensor<T> Empty { get; } = new();
+        /// <param name="source">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static void BroadcastTo<T>(in this ReadOnlyTensorSpan<T> source, in TensorSpan<T> destination)
+        {
+            TensorOperation.ValidateCompatibility<T, T>(source, destination);
+            TensorOperation.Invoke<TensorOperation.CopyTo<T>, T, T>(source, destination);
+        }
+        #endregion
 
+        #region Concatenate
         /// <summary>
-        /// Gets a value indicating whether this <see cref="Tensor{T}"/> is empty.
+        /// Join a sequence of tensors along an existing axis.
         /// </summary>
-        /// <value><see langword="true"/> if this tensor is empty; otherwise, <see langword="false"/>.</value>
-        public bool IsEmpty => _lengths.Length == 0;
+        /// <param name="tensors">The tensors must have the same shape, except in the dimension corresponding to axis (the first, by default).</param>
+        public static Tensor<T> Concatenate<T>(params scoped ReadOnlySpan<Tensor<T>> tensors)
+        {
+            return ConcatenateOnDimension(0, tensors);
+        }
 
         /// <summary>
-        /// Gets a value indicating whether the backing memory of the <see cref="Tensor{T}"/> is pinned."/>
+        /// Join a sequence of tensors along an existing axis.
         /// </summary>
-        /// <value><see langword="true"/> if the backing memory is pinned; otherwise, <see langword="false"/>.</value>
-        public bool IsPinned => _isPinned;
+        /// <param name="tensors">The tensors must have the same shape, except in the dimension corresponding to axis (the first, by default).</param>
+        /// <param name="dimension">The axis along which the tensors will be joined. If axis is -1, arrays are flattened before use. Default is 0.</param>
+        public static Tensor<T> ConcatenateOnDimension<T>(int dimension, params scoped ReadOnlySpan<Tensor<T>> tensors)
+        {
+            if (tensors.Length < 2)
+                ThrowHelper.ThrowArgument_ConcatenateTooFewTensors();
 
-        /// <summary>
-        /// Gets a value indicating the rank, or number of dimensions, of this <see cref="Tensor{T}"/>.
-        /// </summary>
-        /// <value><see cref="nint"/> with the number of dimensions.</value>
-        public int Rank => _lengths.Length;
+            if (dimension < -1 || dimension > tensors[0].Rank)
+                ThrowHelper.ThrowArgument_InvalidAxis();
 
-        /// <summary>
-        /// The number of items in the <see cref="Tensor{T}"/>.
-        /// </summary>
-        /// <value><see cref="nint"/> with the number of items.</value>
-        public nint FlattenedLength => _flattenedLength;
+            // Calculate total space needed.
+            nint totalLength = 0;
+            for (int i = 0; i < tensors.Length; i++)
+                totalLength += tensors[i].FlattenedLength;
 
-        /// <summary>
-        /// Gets the length of each dimension in this <see cref="Tensor{T}"/>.
-        /// </summary>
-        /// <value><see cref="ReadOnlySpan{T}"/> with the lengths of each dimension.</value>
-        public ReadOnlySpan<nint> Lengths => _lengths;
+            nint sumOfAxis = 0;
+            // If axis != -1, make sure all dimensions except the one to concatenate on match.
+            if (dimension != -1)
+            {
+                sumOfAxis = tensors[0].Lengths[dimension];
+                for (int i = 1; i < tensors.Length; i++)
+                {
+                    if (tensors[0].Rank != tensors[i].Rank)
+                        ThrowHelper.ThrowArgument_InvalidConcatenateShape();
+                    for (int j = 0; j < tensors[0].Rank; j++)
+                    {
+                        if (j != dimension)
+                        {
+                            if (tensors[0].Lengths[j] != tensors[i].Lengths[j])
+                                ThrowHelper.ThrowArgument_InvalidConcatenateShape();
+                        }
+                    }
+                    sumOfAxis += tensors[i].Lengths[dimension];
+                }
+            }
 
-        /// <summary>
-        /// Gets the length of each dimension in this <see cref="Tensor{T}"/>.
-        /// </summary>
-        /// <value><see cref="ReadOnlySpan{T}"/> with the lengths of each dimension.</value>
-        ReadOnlySpan<nint> IReadOnlyTensor.Lengths => _lengths;
+            Tensor<T> tensor;
+            if (dimension == -1)
+            {
+                tensor = Tensor.Create<T>([totalLength]);
+            }
+            else
+            {
+                nint[] lengths = new nint[tensors[0].Rank];
+                tensors[0].Lengths.CopyTo(lengths);
+                lengths[dimension] = sumOfAxis;
+                tensor = Tensor.Create<T>(lengths);
+            }
 
+            ConcatenateOnDimension(dimension, tensors, tensor);
+            return tensor;
+        }
 
         /// <summary>
-        /// Gets the strides of each dimension in this <see cref="Tensor{T}"/>.
+        /// Join a sequence of tensors along an existing axis.
         /// </summary>
-        /// <value><see cref="ReadOnlySpan{T}"/> with the strides of each dimension.</value>
-        public ReadOnlySpan<nint> Strides => _strides;
+        /// <param name="tensors">The tensors must have the same shape, except in the dimension corresponding to axis (the first, by default).</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Concatenate<T>(scoped ReadOnlySpan<Tensor<T>> tensors, in TensorSpan<T> destination)
+        {
+            return ref ConcatenateOnDimension(0, tensors, destination);
+        }
 
         /// <summary>
-        /// Gets the strides of each dimension in this <see cref="Tensor{T}"/>.
+        /// Join a sequence of tensors along an existing axis.
         /// </summary>
-        /// <value><see cref="ReadOnlySpan{T}"/> with the strides of each dimension.</value>
-        ReadOnlySpan<nint> IReadOnlyTensor.Strides => _strides;
+        /// <param name="tensors">The tensors must have the same shape, except in the dimension corresponding to axis (the first, by default).</param>
+        /// <param name="dimension">The axis along which the tensors will be joined. If axis is -1, arrays are flattened before use. Default is 0.</param>
+        /// <param name="destination"></param>
 
-        bool ITensor.IsReadOnly => false;
+        public static ref readonly TensorSpan<T> ConcatenateOnDimension<T>(int dimension, scoped ReadOnlySpan<Tensor<T>> tensors, in TensorSpan<T> destination)
+        {
+            if (tensors.Length < 2)
+                ThrowHelper.ThrowArgument_ConcatenateTooFewTensors();
 
-        object IReadOnlyTensor.this[params scoped ReadOnlySpan<NIndex> indexes] => this[indexes]!;
+            if (dimension < -1 || dimension > tensors[0].Rank)
+                ThrowHelper.ThrowArgument_InvalidAxis();
 
-        object IReadOnlyTensor.this[params scoped ReadOnlySpan<nint> indexes] => this[indexes]!;
+            // Calculate total space needed.
+            nint totalLength = 0;
+            for (int i = 0; i < tensors.Length; i++)
+                totalLength += tensors[i].FlattenedLength;
 
-        object ITensor.this[params scoped ReadOnlySpan<NIndex> indexes] { get => this[indexes]!; set => this[indexes] = (T)value; }
-        object ITensor.this[params scoped ReadOnlySpan<nint> indexes] { get => this[indexes]!; set => this[indexes] = (T)value; }
+            // If axis != -1, make sure all dimensions except the one to concatenate on match.
+            if (dimension != -1)
+            {
+                nint sumOfAxis = tensors[0].Lengths[dimension];
+                for (int i = 1; i < tensors.Length; i++)
+                {
+                    if (tensors[0].Rank != tensors[i].Rank)
+                        ThrowHelper.ThrowArgument_InvalidConcatenateShape();
+                    for (int j = 0; j < tensors[0].Rank; j++)
+                    {
+                        if (j != dimension)
+                        {
+                            if (tensors[0].Lengths[j] != tensors[i].Lengths[j])
+                                ThrowHelper.ThrowArgument_InvalidConcatenateShape();
+                        }
+                    }
+                    sumOfAxis += tensors[i].Lengths[dimension];
+                }
 
-        /// <summary>
-        /// Returns a reference to specified element of the Tensor.
-        /// </summary>
-        /// <param name="indexes"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
-        /// </exception>
-        public ref T this[params scoped ReadOnlySpan<nint> indexes] => ref AsTensorSpan()[indexes];
+                // Make sure the destination tensor has the correct shape.
+                nint[] lengths = new nint[tensors[0].Rank];
+                tensors[0].Lengths.CopyTo(lengths);
+                lengths[dimension] = sumOfAxis;
 
-        /// <summary>
-        /// Returns a reference to specified element of the Tensor.
-        /// </summary>
-        /// <param name="indexes"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
-        /// </exception>
-        public ref T this[params scoped ReadOnlySpan<NIndex> indexes] => ref AsTensorSpan()[indexes];
+                if (!TensorShape.AreLengthsTheSame(destination.Lengths, lengths))
+                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
+            }
+            Span<T> dstSpan = MemoryMarshal.CreateSpan(ref destination._reference, (int)totalLength);
 
-        /// <summary>
-        /// Returns a slice of the Tensor.
-        /// </summary>
-        /// <param name="ranges"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
-        /// </exception>
-        public Tensor<T> this[params ReadOnlySpan<NRange> ranges]
-        {
-            get
+            if (dimension == 0 || dimension == -1)
             {
-                if (ranges.Length != Rank)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-
-                return Slice(ranges);
+                for (int i = 0; i < tensors.Length; i++)
+                {
+                    TensorOperation.Invoke<TensorOperation.CopyTo<T>, T, T>(tensors[i], dstSpan);
+                    dstSpan = dstSpan.Slice((int)tensors[i].FlattenedLength);
+                }
             }
-            set
+            else
             {
-                TensorSpan<T> srcSpan;
-                if (ranges == ReadOnlySpan<NRange>.Empty)
+                Span<NRange> ranges = TensorOperation.RentedBuffer.CreateUninitialized(destination.Rank, out TensorOperation.RentedBuffer<NRange> rentedBuffer);
+                for (int i = 0; i < dimension; i++)
                 {
-                    if (!Lengths.SequenceEqual(value.Lengths))
-                        ThrowHelper.ThrowArgument_SetSliceNoRange(nameof(value));
-                    srcSpan = AsTensorSpan().Slice(Lengths);
+                    ranges[i] = 0..1;
                 }
-                else
-                    srcSpan = AsTensorSpan().Slice(ranges);
+                for (int i = dimension; i < destination.Rank; i++)
+                {
+                    ranges[i] = ..;
+                }
+
+                bool hasMore = true;
+                while (hasMore)
+                {
+                    for (int i = 0; i < tensors.Length; i++)
+                    {
+                        Tensor<T> slice = tensors[i].Slice(ranges);
+                        TensorOperation.Invoke<TensorOperation.CopyTo<T>, T, T>(slice, dstSpan);
+                        dstSpan = dstSpan.Slice((int)slice.FlattenedLength);
+                    }
+                    hasMore = IncrementIndexes(ranges, dimension, destination.Lengths);
+                }
+                rentedBuffer.Dispose();
+            }
+            return ref destination;
+        }
+
+        private static bool IncrementIndexes(Span<NRange> ranges, int dimension, ReadOnlySpan<nint> lengths)
+        {
+            NRange curRange = ranges[dimension - 1];
+            ranges[dimension - 1] = new NRange(curRange.Start.Value + 1, curRange.End.Value + 1);
 
-                if (!srcSpan.Lengths.SequenceEqual(value.Lengths))
-                    ThrowHelper.ThrowArgument_SetSliceInvalidShapes(nameof(value));
+            for (int i = dimension - 1; i >= 0; i--)
+            {
+                if (ranges[i].Start.Value >= lengths[i])
+                {
+                    ranges[i] = 0..1;
+                    if (i == 0)
+                        return false;
+                    ranges[i - 1] = new NRange(ranges[i - 1].Start.Value + 1, ranges[i - 1].End.Value + 1);
+                }
+            }
+            return true;
+        }
 
-                value.AsTensorSpan().CopyTo(srcSpan);
+        private static nint CalculateCopyLength(ReadOnlySpan<nint> lengths, int startingAxis)
+        {
+            // When starting axis is -1 we want all the data at once same as if starting axis is 0
+            if (startingAxis == -1)
+                startingAxis = 0;
+            nint length = 1;
+            for (int i = startingAxis; i < lengths.Length; i++)
+            {
+                length *= lengths[i];
             }
+            return length;
         }
+        #endregion
 
-        /// <summary>
-        /// Returns the specified element of the Tensor.
-        /// </summary>
-        /// <param name="indexes"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
-        /// </exception>
-        T ITensor<Tensor<T>, T>.this[params ReadOnlySpan<nint> indexes]
+        #region Create
+        /// <inheritdoc cref="ITensor{TSelf, T}.Create(ReadOnlySpan{nint}, bool)" />
+        /// <returns>A new tensor with the specified lengths.</returns>
+        public static Tensor<T> Create<T>(scoped ReadOnlySpan<nint> lengths, bool pinned = false)
+            => new Tensor<T>(lengths, strides: [], pinned);
+
+        /// <inheritdoc cref="ITensor{TSelf, T}.Create(ReadOnlySpan{nint}, ReadOnlySpan{nint}, bool)" />
+        /// <returns>A new tensor with the specified <paramref name="lengths" /> and <paramref name="strides" />.</returns>
+        public static Tensor<T> Create<T>(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned = false)
+            => new Tensor<T>(lengths, strides, pinned);
+
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[])" />
+        /// <returns>A new tensor that uses <paramref name="array" /> as its backing buffer.</returns>
+        public static Tensor<T> Create<T>(T[] array)
+            => new Tensor<T>(array);
+
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[], ReadOnlySpan{nint})" />
+        /// <returns>A new tensor that uses <paramref name="array" /> as its backing buffer and with the specified <paramref name="lengths" />.</returns>
+        public static Tensor<T> Create<T>(T[] array, scoped ReadOnlySpan<nint> lengths)
+            => new Tensor<T>(array, lengths);
+
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[], ReadOnlySpan{nint}, ReadOnlySpan{nint})" />
+        /// <returns>A new tensor that uses <paramref name="array" /> as its backing buffer and with the specified <paramref name="lengths" /> and <paramref name="strides"/>.</returns>
+        public static Tensor<T> Create<T>(T[] array, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+            => new Tensor<T>(array, lengths, strides);
+
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[], int, ReadOnlySpan{nint}, ReadOnlySpan{nint})" />
+        /// <returns>A new tensor that uses <paramref name="array" /> as its backing buffer and with the specified <paramref name="lengths" /> and <paramref name="strides" />.</returns>
+        public static Tensor<T> Create<T>(T[] array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+            => new Tensor<T>(array, start, lengths, strides);
+
+        /// <returns>A new tensor that contains elements copied from <paramref name="enumerable" />.</returns>
+        public static Tensor<T> Create<T>(IEnumerable<T> enumerable, bool pinned = false)
         {
-            get
+            if (pinned)
             {
-                return this[indexes];
+                T[] array = enumerable.ToArray();
+
+                Tensor<T> tensor = CreateUninitialized<T>([array.Length], pinned);
+                array.CopyTo(tensor._values);
+
+                return tensor;
             }
-            set
+            else
             {
-                this[indexes] = value;
+                T[] array = enumerable.ToArray();
+                return Create(array);
             }
         }
 
-        /// <summary>
-        /// Returns the specified element of the Tensor.
-        /// </summary>
-        /// <param name="indexes"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
-        /// </exception>
-        T ITensor<Tensor<T>, T>.this[params ReadOnlySpan<NIndex> indexes]
+        /// <inheritdoc cref="Create{T}(IEnumerable{T}, ReadOnlySpan{nint}, bool)" />
+        /// <returns>A new tensor that contains elements copied from <paramref name="enumerable" /> and with the specified <paramref name="lengths" />.</returns>
+        public static Tensor<T> Create<T>(IEnumerable<T> enumerable, scoped ReadOnlySpan<nint> lengths, bool pinned = false)
+            => Create(enumerable, lengths, strides: [], pinned);
+
+        /// <inheritdoc cref="Create{T}(IEnumerable{T}, ReadOnlySpan{nint}, ReadOnlySpan{nint}, bool)" />
+        /// <returns>A new tensor that contains elements copied from <paramref name="enumerable" /> and with the specified <paramref name="lengths" /> and <paramref name="strides" />.</returns>
+        public static Tensor<T> Create<T>(IEnumerable<T> enumerable, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned = false)
         {
-            get
+            if (pinned)
             {
-                return this[indexes];
+                T[] array = enumerable.ToArray();
+
+                Tensor<T> tensor = CreateUninitialized<T>(lengths, strides, pinned);
+                array.CopyTo(tensor._values);
+
+                return tensor;
             }
-            set
+            else
             {
-                this[indexes] = value;
+                T[] array = enumerable.ToArray();
+                return Create(array, lengths, strides);
             }
         }
 
         /// <summary>
-        /// Returns the specified element of the ReadOnlyTensor.
+        /// Creates a <see cref="Tensor{T}"/> and initializes it with random data in a gaussian normal distribution.
         /// </summary>
-        /// <param name="indexes"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
-        /// </exception>
-        T IReadOnlyTensor<Tensor<T>, T>.this[params ReadOnlySpan<nint> indexes] => AsReadOnlyTensorSpan()[indexes];
+        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
+        public static Tensor<T> CreateAndFillGaussianNormalDistribution<T>(scoped ReadOnlySpan<nint> lengths)
+            where T : IFloatingPoint<T>
+        {
+            return CreateAndFillGaussianNormalDistribution<T>(Random.Shared, lengths);
+        }
 
         /// <summary>
-        /// Returns the specified element of the ReadOnlyTensor.
+        /// Creates a <see cref="Tensor{T}"/> and initializes it with random data in a gaussian normal distribution.
         /// </summary>
-        /// <param name="indexes"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
-        /// </exception>
-        T IReadOnlyTensor<Tensor<T>, T>.this[params ReadOnlySpan<NIndex> indexes] => AsReadOnlyTensorSpan()[indexes];
+        /// <param name="random"></param>
+        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
+        public static Tensor<T> CreateAndFillGaussianNormalDistribution<T>(Random random, scoped ReadOnlySpan<nint> lengths)
+            where T : IFloatingPoint<T>
+        {
+            Tensor<T> tensor = CreateUninitialized<T>(lengths);
+            FillGaussianNormalDistribution<T>(tensor, random);
+            return tensor;
+        }
+
 
         /// <summary>
-        /// Returns a slice of the ReadOnlyTensor.
+        /// Creates a <see cref="Tensor{T}"/> and initializes it with random data uniformly distributed.
         /// </summary>
-        /// <param name="ranges"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
-        /// </exception>
-        Tensor<T> IReadOnlyTensor<Tensor<T>, T>.this[params ReadOnlySpan<NRange> ranges]
+        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
+        public static Tensor<T> CreateAndFillUniformDistribution<T>(scoped ReadOnlySpan<nint> lengths)
+            where T : IFloatingPoint<T>
         {
-            get
-            {
-                if (ranges.Length != Rank)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-
-                return Slice(ranges);
-            }
+            return CreateAndFillUniformDistribution<T>(Random.Shared, lengths);
         }
 
-        // REVIEW: WE WILL WANT THIS CHANGED FROM A BOOL TO SOME FILTER EXPRESSION.
         /// <summary>
-        ///
+        /// Creates a <see cref="Tensor{T}"/> and initializes it with random data uniformly distributed.
         /// </summary>
-        /// <param name="filter"></param>
-        /// <returns></returns>
-        /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public Tensor<T> this[Tensor<bool> filter]
+        /// <param name="random"></param>
+        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
+        public static Tensor<T> CreateAndFillUniformDistribution<T>(Random random, scoped ReadOnlySpan<nint> lengths)
+            where T : IFloatingPoint<T>
         {
-            get
-            {
-                if (filter.Lengths.Length != Lengths.Length)
-                    throw new ArgumentOutOfRangeException(nameof(filter), "Number of dimensions does not equal the number of dimensions in the span");
-
-                for (int i = 0; i < filter.Lengths.Length; i++)
-                {
-                    if (filter.Lengths[i] != Lengths[i])
-                        ThrowHelper.ThrowArgument_FilterTensorMustEqualTensorLength();
-                }
-
-                Span<T> srcSpan = _values;
-                Span<bool> filterSpan = filter._values;
-
-                nint linearLength = TensorHelpers.CountTrueElements(filter);
+            Tensor<T> tensor = CreateUninitialized<T>(lengths);
+            FillUniformDistribution<T>(tensor, random);
+            return tensor;
+        }
 
-                T[] values = _isPinned ? GC.AllocateArray<T>((int)linearLength, _isPinned) : (new T[linearLength]);
-                int index = 0;
-                for (int i = 0; i < filterSpan.Length; i++)
-                {
-                    if (filterSpan[i])
-                    {
-                        values[i] = srcSpan[index++];
-                    }
-                }
+        /// <inheritdoc cref="ITensor{TSelf, T}.CreateUninitialized(ReadOnlySpan{nint}, bool)" />
+        public static Tensor<T> CreateUninitialized<T>(scoped ReadOnlySpan<nint> lengths, bool pinned = false)
+        {
+            TensorShape shape = TensorShape.Create(lengths, strides: []);
+            T[] array = GC.AllocateUninitializedArray<T>(checked((int)(shape.LinearLength)), pinned);
+            return new Tensor<T>(array, in shape, pinned);
+        }
 
-                return new Tensor<T>(values, [linearLength], _memoryOffset, _isPinned);
-            }
+        /// <inheritdoc cref="ITensor{TSelf, T}.CreateUninitialized(ReadOnlySpan{nint}, ReadOnlySpan{nint}, bool)" />
+        public static Tensor<T> CreateUninitialized<T>(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned = false)
+        {
+            TensorShape shape = TensorShape.Create(lengths, strides);
+            T[] values = GC.AllocateUninitializedArray<T>(checked((int)(shape.LinearLength)), pinned);
+            return new Tensor<T>(values, in shape, pinned);
         }
+        #endregion
 
+        #region Fill
         /// <summary>
-        /// Defines an implicit conversion of an array to a <see cref="Tensor{T}"/>.
+        /// Fills the given <see cref="TensorSpan{T}"/> with random data in a Gaussian normal distribution. <see cref="System.Random"/>
+        /// can optionally be provided for seeding.
         /// </summary>
-        public static implicit operator Tensor<T>(T[] array) => new Tensor<T>(array, [array.Length], memoryOffset: 0);
+        /// <typeparam name="T">The element type.</typeparam>
+        /// <param name="destination">The destination <see cref="TensorSpan{T}"/> where the data will be stored.</param>
+        /// <param name="random"><see cref="System.Random"/> to provide random seeding. Defaults to <see cref="Random.Shared"/> if not provided.</param>
+        /// <returns></returns>
+        public static ref readonly TensorSpan<T> FillGaussianNormalDistribution<T>(in TensorSpan<T> destination, Random? random = null) where T : IFloatingPoint<T>
+        {
+            Span<T> span = MemoryMarshal.CreateSpan<T>(ref destination._reference, (int)destination._shape.LinearLength);
+            random ??= Random.Shared;
 
-        /// <summary>
-        /// Defines an implicit conversion of a <see cref="Tensor{T}"/> to a <see cref="TensorSpan{T}"/>.
-        /// </summary>
-        public static implicit operator TensorSpan<T>(Tensor<T> value) => value.AsTensorSpan();
+            for (int i = 0; i < span.Length; i++)
+            {
+                double u1 = 1.0 - random.NextDouble();
+                double u2 = 1.0 - random.NextDouble();
+                span[i] = T.CreateChecked(Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2));
+            }
 
-        /// <summary>
-        /// Defines an implicit conversion of a <see cref="Tensor{T}"/> to a <see cref="TensorSpan{T}"/>.
-        /// </summary>
-        public static implicit operator ReadOnlyTensorSpan<T>(Tensor<T> value) => value.AsReadOnlyTensorSpan();
+            return ref destination;
+        }
 
         /// <summary>
-        /// Converts this <see cref="Tensor{T}"/> to a <see cref="TensorSpan{T}"/> pointing to the same backing memory."/>
+        /// Fills the given <see cref="TensorSpan{T}"/> with random data in a uniform distribution. <see cref="System.Random"/>
+        /// can optionally be provided for seeding.
         /// </summary>
-        /// <returns><see cref="TensorSpan{T}"/></returns>
-        public TensorSpan<T> AsTensorSpan() => new TensorSpan<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_values), _memoryOffset), _lengths, _strides, _values.Length - _memoryOffset);
+        /// <typeparam name="T">The element type.</typeparam>
+        /// <param name="destination">The destination <see cref="TensorSpan{T}"/> where the data will be stored.</param>
+        /// <param name="random"><see cref="System.Random"/> to provide random seeding. Defaults to <see cref="Random.Shared"/> if not provided.</param>
+        /// <returns></returns>
+        public static ref readonly TensorSpan<T> FillUniformDistribution<T>(in TensorSpan<T> destination, Random? random = null) where T : IFloatingPoint<T>
+        {
+            Span<T> span = MemoryMarshal.CreateSpan<T>(ref destination._reference, (int)destination._shape.LinearLength);
+            random ??= Random.Shared;
+            for (int i = 0; i < span.Length; i++)
+                span[i] = T.CreateChecked(random.NextDouble());
 
-        /// <summary>
-        /// Converts this <see cref="Tensor{T}"/> to a <see cref="TensorSpan{T}"/> pointing to the same backing memory based on the provided ranges."/>
-        /// </summary>
-        /// <param name="start">The ranges you want in the <see cref="TensorSpan{T}"/>.</param>
-        /// <returns><see cref="TensorSpan{T}"/> based on the provided ranges.</returns>
-        public TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<NRange> start) => AsTensorSpan().Slice(start);
+            return ref destination;
+        }
+        #endregion
 
+        #region Equals
         /// <summary>
-        /// Converts this <see cref="Tensor{T}"/> to a <see cref="TensorSpan{T}"/> pointing to the same backing memory based on the provided start locations."/>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> for equality. If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size
+        /// before they are compared. It returns a <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not."/>
         /// </summary>
-        /// <param name="start">The start location you want in the <see cref="TensorSpan{T}"/>.</param>
-        /// <returns><see cref="TensorSpan{T}"/> based on the provided ranges.</returns>
-        public TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<nint> start) => AsTensorSpan().Slice(start);
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <returns>A <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not.</returns>
+        public static Tensor<bool> Equals<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IEqualityOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<bool> destination);
+            TensorOperation.Invoke<TensorOperation.Equals<T>, T, bool>(x, y, destination);
+            return destination;
+        }
 
         /// <summary>
-        /// Converts this <see cref="Tensor{T}"/> to a <see cref="TensorSpan{T}"/> pointing to the same backing memory based on the provided start indexes."/>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> for equality. If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size
+        /// before they are compared. It returns a <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not."/>
         /// </summary>
-        /// <param name="startIndex">The ranges you want in the <see cref="TensorSpan{T}"/>.</param>
-        /// <returns><see cref="TensorSpan{T}"/> based on the provided ranges.</returns>
-        public TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<NIndex> startIndex) => AsTensorSpan().Slice(startIndex);
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="destination"></param>
+        /// <returns>A <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> Equals<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
+            where T : IEqualityOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Equals<T>, T, bool>(x, y, destination);
+            return ref destination;
+        }
 
         /// <summary>
-        /// Converts this <see cref="Tensor{T}"/> to a <see cref="ReadOnlyTensorSpan{T}"/> pointing to the same backing memory."/>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> for equality. If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size
+        /// before they are compared. It returns a <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not."/>
         /// </summary>
-        /// <returns><see cref="ReadOnlyTensorSpan{T}"/></returns>
-        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan() => new ReadOnlyTensorSpan<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_values), _memoryOffset), _lengths, _strides, _flattenedLength);
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second value to compare.</param>
+        /// <returns>A <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not.</returns>
+        public static Tensor<bool> Equals<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IEqualityOperators<T, T, bool>
+        {
+            Tensor<bool> destination = CreateUninitialized<bool>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Equals<T>, T, bool>(x, y, destination);
+            return destination;
+        }
 
         /// <summary>
-        /// Converts this <see cref="Tensor{T}"/> to a <see cref="ReadOnlyTensorSpan{T}"/> pointing to the same backing memory based on the provided ranges."/>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> for equality. If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size
+        /// before they are compared. It returns a <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not."/>
         /// </summary>
-        /// <param name="start">The ranges you want in the <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <returns></returns>
-        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NRange> start) => AsTensorSpan().Slice(start);
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second value to compare.</param>
+        /// <param name="destination"></param>
+        /// <returns>A <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> Equals<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<bool> destination)
+            where T : IEqualityOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Equals<T>, T, bool>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
 
+        #region EqualsAll
         /// <summary>
-        /// Converts this <see cref="Tensor{T}"/> to a <see cref="ReadOnlyTensorSpan{T}"/> pointing to the same backing memory based on the provided start locations."/>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are equal to <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are eqaul to <paramref name="y"/>.
         /// </summary>
-        /// <param name="start">The start locations you want in the <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <returns></returns>
-        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<nint> start) => AsTensorSpan().Slice(start);
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are equal to <paramref name="y"/>.</returns>
+        public static bool EqualsAll<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IEqualityOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y);
+            return TensorOperation.Invoke<TensorOperation.Equals<T>, T>(x, y);
+        }
 
         /// <summary>
-        /// Converts this <see cref="Tensor{T}"/> to a <see cref="ReadOnlyTensorSpan{T}"/> pointing to the same backing memory based on the provided start indexes."/>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are equal to <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are eqaul to <paramref name="y"/>.
         /// </summary>
-        /// <param name="startIndex">The start indexes you want in the <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <returns></returns>
-        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NIndex> startIndex) => AsTensorSpan().Slice(startIndex);
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are equal to <paramref name="y"/>.</returns>
+        public static bool EqualsAll<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IEqualityOperators<T, T, bool> => TensorOperation.Invoke<TensorOperation.Equals<T>, T>(x, y);
+        #endregion
 
+        #region EqualsAny
         /// <summary>
-        /// Returns a reference to the 0th element of the Tensor. If the Tensor is empty, returns null reference.
-        /// It can be used for pinning and is required to support the use of Tensor within a fixed statement.
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are equal to <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are equal to <paramref name="y"/>.
         /// </summary>
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        public ref T GetPinnableReference() => ref AsTensorSpan().GetPinnableReference();
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are equal to <paramref name="y"/>.</returns>
+        public static bool EqualsAny<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IEqualityOperators<T, T, bool>
+        {
+            // The main loop early exits at the first false condition, so the TensorOperation
+            // checks x != y and returns false on first equal. This means we want to negate
+            // whatever the main loop returns as `true` means none are equal.
+
+            TensorOperation.ValidateCompatibility(x, y);
+            return !TensorOperation.Invoke<TensorOperation.EqualsAny<T>, T>(x, y);
+        }
 
         /// <summary>
-        /// Returns a reference to the 0th element of the ReadOnlyTensor. If the ReadOnlyTensor is empty, returns null reference.
-        /// It can be used for pinning and is required to support the use of ReadOnlyTensor within a fixed statement.
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are equal to <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are equal to <paramref name="y"/>.
         /// </summary>
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        ref readonly T IReadOnlyTensor<Tensor<T>, T>.GetPinnableReference() => ref AsReadOnlyTensorSpan().GetPinnableReference();
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are equal to <paramref name="y"/>.</returns>
+        public static bool EqualsAny<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IEqualityOperators<T, T, bool> => !TensorOperation.Invoke<TensorOperation.EqualsAny<T>, T>(x, y);
+        #endregion
 
+        #region FilteredUpdate
         /// <summary>
-        /// Forms a slice out of the given tensor
+        /// Updates the <paramref name="tensor"/> tensor with the <paramref name="value"/> where the <paramref name="filter"/> is true.
         /// </summary>
-        /// <param name="start">The ranges for the slice</param>
-        /// <returns><see cref="Tensor{T}"/> without copying the provided ranges.</returns>
-        public Tensor<T> Slice(params ReadOnlySpan<NRange> start)
+        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="filter">Input filter where if the index is true then it will update the <paramref name="tensor"/>.</param>
+        /// <param name="value">Value to update in the <paramref name="tensor"/>.</param>
+        public static ref readonly TensorSpan<T> FilteredUpdate<T>(in this TensorSpan<T> tensor, scoped in ReadOnlyTensorSpan<bool> filter, T value)
         {
-            if (start.Length != Lengths.Length)
-                throw new ArgumentOutOfRangeException(nameof(start), "Number of dimensions to slice does not equal the number of dimensions in the span");
+            if (filter.Lengths.Length != tensor.Lengths.Length)
+                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(filter));
 
-            scoped Span<nint> lengths;
-            scoped Span<nint> offsets;
-            nint[]? lengthsArray;
-            nint[]? offsetsArray;
-            if (Rank > TensorShape.MaxInlineRank)
-            {
-                lengthsArray = ArrayPool<nint>.Shared.Rent(Rank);
-                lengths = lengthsArray.AsSpan(0, Rank);
+            Span<T> srcSpan = MemoryMarshal.CreateSpan(ref tensor._reference, (int)tensor._shape.LinearLength);
+            Span<bool> filterSpan = MemoryMarshal.CreateSpan(ref filter._reference, (int)tensor._shape.LinearLength);
 
-                offsetsArray = ArrayPool<nint>.Shared.Rent(Rank);
-                offsets = offsetsArray.AsSpan(0, Rank);
-            }
-            else
+            for (int i = 0; i < filterSpan.Length; i++)
             {
-                lengths = stackalloc nint[Rank];
-                offsets = stackalloc nint[Rank];
-
-                lengthsArray = null;
-                offsetsArray = null;
+                if (filterSpan[i])
+                {
+                    srcSpan[i] = value;
+                }
             }
-            lengths.Clear();
-            offsets.Clear();
 
-            for (int i = 0; i < start.Length; i++)
-            {
-                (offsets[i], lengths[i]) = start[i].GetOffsetAndLength(Lengths[i]);
-            }
+            return ref tensor;
+        }
+
+        /// <summary>
+        /// Updates the <paramref name="tensor"/> tensor with the <paramref name="values"/> where the <paramref name="filter"/> is true.
+        /// If dimensions are not the same an exception is thrown.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="filter">Input filter where if the index is true then it will update the <paramref name="tensor"/>.</param>
+        /// <param name="values">Values to update in the <paramref name="tensor"/>.</param>
+        public static ref readonly TensorSpan<T> FilteredUpdate<T>(in this TensorSpan<T> tensor, scoped in ReadOnlyTensorSpan<bool> filter, scoped in ReadOnlyTensorSpan<T> values)
+        {
+            if (filter.Lengths.Length != tensor.Lengths.Length)
+                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(filter));
+            if (values.Rank != 1)
+                ThrowHelper.ThrowArgument_1DTensorRequired(nameof(values));
 
-            // When we have an empty Tensor and someone wants to slice all of it, we should return an empty Tensor.
-            // FlattenedLength is computed everytime so using a local to cache the value.
-            nint flattenedLength = FlattenedLength;
-            int memoryOffset = 0;
+            Span<T> dstSpan = MemoryMarshal.CreateSpan(ref tensor._reference, (int)tensor._shape.LinearLength);
+            Span<bool> filterSpan = MemoryMarshal.CreateSpan(ref filter._reference, (int)tensor._shape.LinearLength);
+            Span<T> valuesSpan = MemoryMarshal.CreateSpan(ref values._reference, (int)values._shape.LinearLength);
 
-            if (flattenedLength != 0)
+            int index = 0;
+            for (int i = 0; i < filterSpan.Length; i++)
             {
-                for (int i = 0; i < offsets.Length; i++)
+                if (filterSpan[i])
                 {
-                    memoryOffset += (int)(Strides[i] * offsets[i]);
+                    dstSpan[i] = valuesSpan[index++];
                 }
             }
 
-            if ((memoryOffset >= _values.Length || memoryOffset < 0) && flattenedLength != 0)
-                ThrowHelper.ThrowIndexOutOfRangeException();
-
-            Tensor<T> toReturn = new Tensor<T>(_values, lengths, Strides, memoryOffset, _isPinned);
+            return ref tensor;
+        }
+        #endregion
 
-            if (offsetsArray != null)
-                ArrayPool<nint>.Shared.Return(offsetsArray);
-            if (lengthsArray != null)
-                ArrayPool<nint>.Shared.Return(lengthsArray);
+        #region GreaterThan
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/> and
+        /// false if they are not.</returns>
+        public static Tensor<bool> GreaterThan<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<bool> destination);
+            TensorOperation.Invoke<TensorOperation.GreaterThan<T>, T, bool>(x, y, destination);
+            return destination;
+        }
 
-            return toReturn;
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="destination"></param>
+        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/> and
+        /// false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> GreaterThan<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.GreaterThan<T>, T, bool>(x, y, destination);
+            return ref destination;
         }
 
         /// <summary>
-        /// Forms a slice out of the given tensor
+        /// Compares the elements of a <see cref="ReadOnlyTensorSpan{T}"/> to see which elements are greater than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
         /// </summary>
-        /// <param name="start">The start indexes for the slice</param>
-        /// <returns><see cref="Tensor{T}"/> without copying the provided ranges.</returns>
-        public Tensor<T> Slice(params ReadOnlySpan<nint> start)
+        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static Tensor<bool> GreaterThan<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool>
         {
-            NRange[] ranges = new NRange[start.Length];
-            for (int i = 0; i < start.Length; i++)
-            {
-                ranges[i] = new NRange(start[i], new NIndex(0, fromEnd: true));
-            }
-            return Slice(ranges);
+            Tensor<bool> destination = Tensor.Create<bool>(x.Lengths, false);
+            GreaterThan(x, y, destination);
+            return destination;
         }
 
         /// <summary>
-        /// Forms a slice out of the given tensor
+        /// Compares the elements of a <see cref="ReadOnlyTensorSpan{T}"/> to see which elements are greater than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
         /// </summary>
-        /// <param name="startIndex">The start indexes for the slice</param>
-        /// <returns><see cref="Tensor{T}"/> without copying the provided ranges.</returns>
-        public Tensor<T> Slice(params ReadOnlySpan<NIndex> startIndex)
+        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <param name="destination"></param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> GreaterThan<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool>
         {
-            NRange[] ranges = new NRange[startIndex.Length];
-            for (int i = 0; i < startIndex.Length; i++)
-            {
-                ranges[i] = new NRange(startIndex[i], new NIndex(0, fromEnd: true));
-            }
-            return Slice(ranges);
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.GreaterThan<T>, T, bool>(x, y, destination);
+            return ref destination;
         }
 
         /// <summary>
-        /// Clears the contents of this tensor.
+        /// Compares <paramref name="x"/> to see which elements are greater than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
         /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public unsafe void Clear() => AsTensorSpan().Clear();
+        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static Tensor<bool> GreaterThan<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => LessThan(y, x);
 
         /// <summary>
-        /// Copies the contents of this tensor into destination span. If the source
-        /// and destinations overlap, this method behaves as if the original values in
-        /// a temporary location before the destination is overwritten.
+        /// Compares <paramref name="x"/> to see which elements are greater than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
         /// </summary>
-        /// <param name="destination">The span to copy items into.</param>
-        /// <exception cref="ArgumentException">
-        /// Thrown when the destination TensorSpan is shorter than the source Tensor.
-        /// </exception>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CopyTo(scoped TensorSpan<T> destination) => AsTensorSpan().CopyTo(destination);
+        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <param name="destination"></param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> GreaterThan<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool> => ref LessThan(y, x, destination);
+        #endregion
 
+        #region GreaterThanAll
         /// <summary>
-        /// Fills the contents of this span with the given value.
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.
         /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Fill(T value) => AsTensorSpan().Fill(value);
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
+        public static bool GreaterThanAll<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y);
+            return TensorOperation.Invoke<TensorOperation.GreaterThan<T>, T>(x, y);
+        }
 
         /// <summary>
-        /// Fills the contents of this span with the given value.
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.
         /// </summary>
-        public void Fill(object value) => Fill(value is T t ? t : throw new ArgumentException($"Cannot convert {value} to {typeof(T)}"));
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
+        public static bool GreaterThanAll<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool> => TensorOperation.Invoke<TensorOperation.GreaterThan<T>, T>(x, y);
 
         /// <summary>
-        /// Copies the contents of this tensor into destination span. If the source
-        /// and destinations overlap, this method behaves as if the original values in
-        /// a temporary location before the destination is overwritten.
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="y"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are greater than <paramref name="y"/>.
         /// </summary>
-        /// <param name="destination">The span to copy items into.</param>
-        /// <returns>If the destination span is shorter than the source tensor, this method
-        /// return false and no data is written to the destination.</returns>
-        public bool TryCopyTo(scoped TensorSpan<T> destination) => AsTensorSpan().TryCopyTo(destination);
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are greater than <paramref name="y"/>.</returns>
+        public static bool GreaterThanAll<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => LessThanAll(y, x);
+        #endregion
 
+        #region GreaterThanAny
         /// <summary>
-        /// Flattens the contents of this Tensor into the provided <see cref="Span{T}"/>.
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.
         /// </summary>
-        /// <param name="destination">The span to copy items into.</param>
-        public void FlattenTo(scoped Span<T> destination) => AsTensorSpan().FlattenTo(destination);
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
+        public static bool GreaterThanAny<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            // The main loop early exits at the first false condition, so the TensorOperation
+            // checks !(x > y) and returns false on first equal. This means we want to negate
+            // whatever the main loop returns as `true` means none are equal.
+
+            TensorOperation.ValidateCompatibility(x, y);
+            return !TensorOperation.Invoke<TensorOperation.GreaterThanAny<T>, T>(x, y);
+        }
 
         /// <summary>
-        /// Flattens the contents of this Tensor into the provided <see cref="Span{T}"/>.
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.
         /// </summary>
-        /// <param name="destination">The span to copy items into.</param>
-        public bool TryFlattenTo(scoped Span<T> destination) => AsTensorSpan().TryFlattenTo(destination);
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
+        public static bool GreaterThanAny<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool> => !TensorOperation.Invoke<TensorOperation.GreaterThanAny<T>, T>(x, y);
 
-        // IEnumerable
         /// <summary>
-        /// Gets an <see cref="IEnumerator{T}"/> for the <see cref="Tensor{T}"/>.
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="y"/> are greater than <paramref name="x"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are greater than <paramref name="x"/>.
         /// </summary>
-        /// <returns><see cref="IEnumerator{T}"/></returns>
-        IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
+        /// <param name="y">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="x">Value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are greater than <paramref name="x"/>.</returns>
+        public static bool GreaterThanAny<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => LessThanAny(y, x);
+        #endregion
 
-        // IEnumerable
+        #region GreaterThanOrEqual
         /// <summary>
-        /// Gets an <see cref="IEnumerator{T}"/> for the <see cref="Tensor{T}"/>.
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are greater than or equal to <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
         /// </summary>
-        /// <returns><see cref="IEnumerator{T}"/></returns>
-        public IEnumerator<T> GetEnumerator() => new Enumerator(this);
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/> and
+        /// false if they are not.</returns>
+        public static Tensor<bool> GreaterThanOrEqual<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<bool> destination);
+            TensorOperation.Invoke<TensorOperation.GreaterThanOrEqual<T>, T, bool>(x, y, destination);
+            return destination;
+        }
 
         /// <summary>
-        /// Gets an <see cref="IEnumerator"/> for the <see cref="Tensor{T}"/>."/>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are greater than or equal to <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
         /// </summary>
-        /// <returns></returns>
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="destination"></param>
+        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/> and
+        /// false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> GreaterThanOrEqual<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.GreaterThanOrEqual<T>, T, bool>(x, y, destination);
+            return ref destination;
+        }
 
-        private struct Enumerator : IEnumerator<T>
+        /// <summary>
+        /// Compares the elements of a <see cref="ReadOnlyTensorSpan{T}"/> to see which elements are greater than or equal to <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static Tensor<bool> GreaterThanOrEqual<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool>
         {
-            /// <summary>The span being enumerated.</summary>
-            private readonly Tensor<T> _tensor;
-            /// <summary>
-            ///
-            /// </summary>
-            private nint[] _curIndices;
-            /// <summary>The total item count.</summary>
-            private nint _items;
+            Tensor<bool> destination = Tensor.Create<bool>(x.Lengths, false);
+            GreaterThanOrEqual(x, y, destination);
+            return destination;
+        }
 
-            /// <summary>Initialize the enumerator.</summary>
-            /// <param name="tensor">The tensor to enumerate.</param>
-            internal Enumerator(Tensor<T> tensor)
-            {
-                _tensor = tensor;
-                _items = -1;
-                _curIndices = new nint[_tensor.Rank];
-                _curIndices[_tensor.Rank - 1] = -1;
-            }
+        /// <summary>
+        /// Compares the elements of a <see cref="ReadOnlyTensorSpan{T}"/> to see which elements are greater than or equal to <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <param name="destination"></param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> GreaterThanOrEqual<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.GreaterThanOrEqual<T>, T, bool>(x, y, destination);
+            return ref destination;
+        }
 
-            /// <summary>Advances the enumerator to the next element of the span.</summary>
-            public bool MoveNext()
-            {
-                TensorSpanHelpers.AdjustIndexes(_tensor.Rank - 1, 1, ref _curIndices, _tensor.Lengths);
+        /// <summary>
+        /// Compares <paramref name="x"/> to see which elements are greater than or equal to <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static Tensor<bool> GreaterThanOrEqual<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => LessThanOrEqual(y, x);
 
-                _items++;
-                return _items < _tensor.FlattenedLength;
-            }
+        /// <summary>
+        /// Compares <paramref name="x"/> to see which elements are greater than or equal to <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <param name="destination"></param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> GreaterThanOrEqual<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool> => ref LessThanOrEqual(y, x, destination);
+        #endregion
 
-            /// <summary>
-            /// Resets the enumerator to the beginning of the span.
-            /// </summary>
-            public void Reset()
-            {
-                Array.Clear(_curIndices);
-                _curIndices[_tensor.Rank - 1] = -1;
-            }
+        #region GreaterThanOrEqualAll
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
+        public static bool GreaterThanOrEqualAll<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y);
+            return TensorOperation.Invoke<TensorOperation.GreaterThanOrEqual<T>, T>(x, y);
+        }
 
-            /// <summary>
-            ///
-            /// </summary>
-            public void Dispose()
-            {
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
+        public static bool GreaterThanOrEqualAll<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool> => TensorOperation.Invoke<TensorOperation.GreaterThanOrEqual<T>, T>(x, y);
 
-            }
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="y"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are greater than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are greater than <paramref name="y"/>.</returns>
+        public static bool GreaterThanOrEqualAll<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => LessThanOrEqualAll(y, x);
+        #endregion
 
-            /// <summary>
-            /// Current T value of the <see cref="IEnumerator{T}"/>
-            /// </summary>
-            T IEnumerator<T>.Current => _tensor[_curIndices];
+        #region GreaterThanOrEqualAny
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
+        public static bool GreaterThanOrEqualAny<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            // The main loop early exits at the first false condition, so the TensorOperation
+            // checks !(x >= y) and returns false on first equal. This means we want to negate
+            // whatever the main loop returns as `true` means none are equal.
 
-            /// <summary>
-            /// Current <see cref="object"/> of the <see cref="IEnumerator"/>
-            /// </summary>
-            object? IEnumerator.Current => _tensor[_curIndices];
+            TensorOperation.ValidateCompatibility(x, y);
+            return !TensorOperation.Invoke<TensorOperation.GreaterThanOrEqualAny<T>, T>(x, y);
         }
 
-        // REVIEW: PENDING API REVIEW TO DETERMINE IMPLEMENTATION
         /// <summary>
-        /// Gets the hash code for the <see cref="Tensor{T}"/>.
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are greater than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.
         /// </summary>
-        /// <returns>The hash code of the tensor.</returns>
-        /// <exception cref="NotImplementedException">In all cases.</exception>
-        public override int GetHashCode()
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
+        public static bool GreaterThanOrEqualAny<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool> => !TensorOperation.Invoke<TensorOperation.GreaterThanOrEqualAny<T>, T>(x, y);
+
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="y"/> are greater than <paramref name="x"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are greater than <paramref name="x"/>.
+        /// </summary>
+        /// <param name="y">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="x">Value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are greater than <paramref name="x"/>.</returns>
+        public static bool GreaterThanOrEqualAny<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => LessThanOrEqualAny(y, x);
+        #endregion
+
+        #region LessThan
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/> and
+        /// false if they are not.</returns>
+        public static Tensor<bool> LessThan<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
         {
-            throw new NotImplementedException();
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<bool> destination);
+            TensorOperation.Invoke<TensorOperation.LessThan<T>, T, bool>(x, y, destination);
+            return destination;
         }
 
         /// <summary>
-        /// Get a string representation of the tensor.
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
         /// </summary>
-        private void ToMetadataString(StringBuilder sb)
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="destination"></param>
+        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/> and
+        /// false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> LessThan<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool>
         {
-            sb.Append('[');
-
-            for (int i = 0; i < Rank; i++)
-            {
-                sb.Append(Lengths[i]);
-                if (i + 1 < Rank)
-                    sb.Append('x');
-            }
-
-            sb.Append($"], type = {typeof(T)}, isPinned = {IsPinned}");
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.LessThan<T>, T, bool>(x, y, destination);
+            return ref destination;
         }
 
         /// <summary>
-        /// Creates a <see cref="string"/> representation of the <see cref="TensorSpan{T}"/>."/>
+        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
         /// </summary>
-        /// <param name="maximumLengths">Maximum Length of each dimension</param>
-        /// <returns>A <see cref="string"/> representation of the <see cref="Tensor{T}"/></returns>
-        public string ToString(params ReadOnlySpan<nint> maximumLengths)
+        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static Tensor<bool> LessThan<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool>
         {
-            if (maximumLengths.IsEmpty)
-            {
-                maximumLengths = Rank <= TensorShape.MaxInlineRank ? stackalloc nint[Rank] : new nint[Rank];
-            }
-
-            var sb = new StringBuilder();
-            ToMetadataString(sb);
-            sb.AppendLine("{");
-            ((ReadOnlyTensorSpan<T>)AsTensorSpan()).ToString(sb, maximumLengths);
-            sb.AppendLine("}");
-            return sb.ToString();
+            Tensor<bool> destination = Tensor.Create<bool>(x.Lengths, false);
+            LessThan(x, y, destination);
+            return destination;
         }
 
         /// <summary>
-        /// Pins and gets a <see cref="MemoryHandle"/> to the backing memory.
+        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
         /// </summary>
-        /// <returns>A <see cref="MemoryHandle"/> which has pinned the backing memory.</returns>
-        public MemoryHandle GetPinnedHandle()
+        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <param name="destination"></param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> LessThan<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool>
         {
-            GCHandle handle = GCHandle.Alloc(_values, GCHandleType.Pinned);
-            unsafe
-            {
-                return new MemoryHandle(Unsafe.AsPointer(ref GetPinnableReference()), handle);
-            }
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.LessThan<T>, T, bool>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static Tensor<bool> LessThan<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => GreaterThan(y, x);
+
+        /// <summary>
+        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <param name="destination"></param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> LessThan<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool> => ref GreaterThan(y, x, destination);
+        #endregion
+
+        #region LessThanAll
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
+        public static bool LessThanAll<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y);
+            return TensorOperation.Invoke<TensorOperation.LessThan<T>, T>(x, y);
+        }
+
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
+        public static bool LessThanAll<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool> => TensorOperation.Invoke<TensorOperation.LessThan<T>, T>(x, y);
+
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="y"/> are less than <paramref name="x"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are less than <paramref name="x"/>.
+        /// </summary>
+        /// <param name="y">First value to compare.</param>
+        /// <param name="x">Second value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are less than <paramref name="x"/>.</returns>
+        public static bool LessThanAll<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => GreaterThanAll(y, x);
+        #endregion
+
+        #region LessThanAny
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
+        public static bool LessThanAny<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            // The main loop early exits at the first false condition, so the TensorOperation
+            // checks !(x < y) and returns false on first equal. This means we want to negate
+            // whatever the main loop returns as `true` means none are equal.
+
+            TensorOperation.ValidateCompatibility(x, y);
+            return !TensorOperation.Invoke<TensorOperation.LessThanAny<T>, T>(x, y);
+        }
+
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
+        public static bool LessThanAny<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool> => !TensorOperation.Invoke<TensorOperation.LessThanAny<T>, T>(x, y);
+
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="y"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are less than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First value to compare.</param>
+        /// <param name="y">Second value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are less than <paramref name="y"/>.</returns>
+        public static bool LessThanAny<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => GreaterThanAny(y, x);
+        #endregion
+
+        #region LessThanOrEqual
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/> and
+        /// false if they are not.</returns>
+        public static Tensor<bool> LessThanOrEqual<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<bool> destination);
+            TensorOperation.Invoke<TensorOperation.LessThanOrEqual<T>, T, bool>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="destination"></param>
+        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/> and
+        /// false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> LessThanOrEqual<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.LessThanOrEqual<T>, T, bool>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static Tensor<bool> LessThanOrEqual<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            Tensor<bool> destination = Tensor.Create<bool>(x.Lengths, false);
+            LessThanOrEqual(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <param name="destination"></param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> LessThanOrEqual<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.LessThanOrEqual<T>, T, bool>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static Tensor<bool> LessThanOrEqual<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => GreaterThanOrEqual(y, x);
+
+        /// <summary>
+        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
+        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not."/>
+        /// </summary>
+        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
+        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
+        /// <param name="destination"></param>
+        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
+        /// and false if they are not.</returns>
+        public static ref readonly TensorSpan<bool> LessThanOrEqual<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
+            where T : IComparisonOperators<T, T, bool> => ref GreaterThanOrEqual(y, x, destination);
+        #endregion
+
+        #region LessThanOrEqualAll
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
+        public static bool LessThanOrEqualAll<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            TensorOperation.ValidateCompatibility(x, y);
+            return TensorOperation.Invoke<TensorOperation.LessThanOrEqual<T>, T>(x, y);
+        }
+
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
+        public static bool LessThanOrEqualAll<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool> => TensorOperation.Invoke<TensorOperation.LessThanOrEqual<T>, T>(x, y);
+
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="y"/> are less than <paramref name="x"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are less than <paramref name="x"/>.
+        /// </summary>
+        /// <param name="y">First value to compare.</param>
+        /// <param name="x">Second value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are less than <paramref name="x"/>.</returns>
+        public static bool LessThanOrEqualAll<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => GreaterThanOrEqualAll(y, x);
+        #endregion
+
+        #region LessThanOrEqualAny
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
+        public static bool LessThanOrEqualAny<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool>
+        {
+            // The main loop early exits at the first false condition, so the TensorOperation
+            // checks !(x <= y) and returns false on first equal. This means we want to negate
+            // whatever the main loop returns as `true` means none are equal.
+
+            TensorOperation.ValidateCompatibility(x, y);
+            return !TensorOperation.Invoke<TensorOperation.LessThanOrEqualAny<T>, T>(x, y);
+        }
+
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
+        /// <param name="y">Second value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
+        public static bool LessThanOrEqualAny<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IComparisonOperators<T, T, bool> => !TensorOperation.Invoke<TensorOperation.LessThanOrEqualAny<T>, T>(x, y);
+
+        /// <summary>
+        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="y"/> are less than <paramref name="y"/>.
+        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
+        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are less than <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">First value to compare.</param>
+        /// <param name="y">Second value to compare against.</param>
+        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are less than <paramref name="y"/>.</returns>
+        public static bool LessThanOrEqualAny<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IComparisonOperators<T, T, bool> => GreaterThanOrEqualAny(y, x);
+        #endregion
+
+        #region Permute
+
+        /// <summary>
+        /// Swaps the dimensions of the <paramref name="tensor"/> tensor according to the <paramref name="dimensions"/> parameter.
+        /// If <paramref name="tensor"/> is a 1D tensor, it will return <paramref name="tensor"/>. Otherwise it creates a new <see cref="Tensor{T}"/>
+        /// with the new axis ordering by allocating new memory.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="Tensor{T}"/></param>
+        /// <param name="dimensions"><see cref="ReadOnlySpan{T}"/> with the new axis ordering.</param>
+        public static Tensor<T> PermuteDimensions<T>(this Tensor<T> tensor, ReadOnlySpan<int> dimensions)
+        {
+            if (tensor.Rank == 1)
+            {
+                return tensor;
+            }
+            else
+            {
+                scoped Span<nint> newLengths = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<nint> lengthsRentedBuffer);
+                scoped Span<nint> newStrides = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<nint> stridesRentedBuffer);
+                scoped Span<int> newLinearOrder = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<int> linearOrderRentedBuffer);
+
+                Tensor<T> outTensor;
+
+                if (dimensions.IsEmpty)
+                {
+                    for (int i = 0; i < tensor.Rank; i++)
+                    {
+                        newLengths[i] = tensor.Lengths[tensor.Rank - 1 - i];
+                        newStrides[i] = tensor.Strides[tensor.Rank - 1 - i];
+                        newLinearOrder[i] = tensor._shape.LinearRankOrder[tensor.Rank - 1 - i];
+                    }
+                }
+                else
+                {
+                    if (dimensions.Length != tensor.Lengths.Length)
+                        ThrowHelper.ThrowArgument_PermuteAxisOrder();
+
+                    for (int i = 0; i < dimensions.Length; i++)
+                    {
+                        newLengths[i] = tensor.Lengths[dimensions[i]];
+                        newStrides[i] = tensor.Strides[dimensions[i]];
+                        newLinearOrder[i] = tensor._shape.LinearRankOrder[dimensions[i]];
+                    }
+                }
+                outTensor = new Tensor<T>(tensor._values, tensor._start, newLengths, newStrides, newLinearOrder);
+
+                lengthsRentedBuffer.Dispose();
+                stridesRentedBuffer.Dispose();
+                linearOrderRentedBuffer.Dispose();
+
+                return outTensor;
+            }
+        }
+        #endregion
+
+        #region Reshape
+        /// <summary>
+        /// Reshapes the <paramref name="tensor"/> 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="tensor"><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> tensor, ReadOnlySpan<nint> lengths)
+        {
+            if (tensor.Lengths.SequenceEqual(lengths))
+                return tensor;
+
+            if (!tensor.IsContiguousAndDense && !tensor.Strides.Contains(0))
+            {
+                ThrowHelper.ThrowArgument_CannotReshapeNonContiguousOrDense();
+            }
+
+            nint[] newLengths = lengths.ToArray();
+            // Calculate wildcard info.
+            if (lengths.Contains(-1))
+            {
+                if (lengths.Count(-1) > 1)
+                    ThrowHelper.ThrowArgument_OnlyOneWildcard();
+                nint tempTotal = tensor.FlattenedLength;
+                for (int i = 0; i < lengths.Length; i++)
+                {
+                    if (lengths[i] != -1)
+                    {
+                        tempTotal /= lengths[i];
+                    }
+                }
+                newLengths[lengths.IndexOf(-1)] = tempTotal;
+            }
+
+            nint tempLinear = TensorPrimitives.Product(newLengths);
+            if (tempLinear != tensor.FlattenedLength)
+                ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
+
+            nint[] strides;
+
+            // If all our strides are 0 we can reshape however we like and keep all new strides at 0
+            if (!tensor.Strides.ContainsAnyExcept(0))
+            {
+                strides = new nint[newLengths.Length];
+            }
+            // If we contain a 0 stride we can only add dimensions of length 1.
+            else if (tensor.Strides.Contains(0))
+            {
+                List<nint> origStrides = new List<nint>(tensor.Strides.ToArray());
+                int lengthOffset = 0;
+                for (int i = 0; i < newLengths.Length; i++)
+                {
+                    if (lengthOffset < tensor.Rank && newLengths[i] == tensor.Lengths[lengthOffset])
+                        lengthOffset++;
+                    else if (newLengths[i] == 1)
+                    {
+                        if (lengthOffset == tensor.Rank)
+                            origStrides.Add(tensor.Strides[lengthOffset - 1]);
+                        else
+                            origStrides.Insert(i, tensor.Strides[i] * tensor.Lengths[i]);
+                    }
+                    else
+                        ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
+                }
+                strides = origStrides.ToArray();
+            }
+            else
+                strides = [];
+
+            return new Tensor<T>(tensor._values, tensor._start, lengths, strides);
+        }
+
+        /// <summary>
+        /// Reshapes the <paramref name="tensor"/> 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="tensor"><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>(in this TensorSpan<T> tensor, scoped ReadOnlySpan<nint> lengths)
+        {
+            if (tensor.Lengths.SequenceEqual(lengths))
+                return tensor;
+
+            if (!tensor.IsContiguousAndDense && !tensor.Strides.Contains(0))
+            {
+                ThrowHelper.ThrowArgument_CannotReshapeNonContiguousOrDense();
+            }
+
+            nint[] newLengths = lengths.ToArray();
+            // Calculate wildcard info.
+            if (lengths.Contains(-1))
+            {
+                if (lengths.Count(-1) > 1)
+                    ThrowHelper.ThrowArgument_OnlyOneWildcard();
+                nint tempTotal = tensor.FlattenedLength;
+                for (int i = 0; i < lengths.Length; i++)
+                {
+                    if (lengths[i] != -1)
+                    {
+                        tempTotal /= lengths[i];
+                    }
+                }
+                newLengths[lengths.IndexOf(-1)] = tempTotal;
+
+            }
+
+            nint tempLinear = TensorPrimitives.Product(newLengths);
+            if (tempLinear != tensor.FlattenedLength)
+                ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
+
+            nint[] strides;
+
+            // If all our strides are 0 we can reshape however we like and keep all new strides at 0
+            if (!tensor.Strides.ContainsAnyExcept(0))
+            {
+                strides = new nint[newLengths.Length];
+            }
+            // If we contain a 0 stride we can only add dimensions of length 1.
+            else if (tensor.Strides.Contains(0))
+            {
+                List<nint> origStrides = new List<nint>(tensor.Strides.ToArray());
+                int lengthOffset = 0;
+                for (int i = 0; i < newLengths.Length; i++)
+                {
+                    if (lengthOffset < tensor.Rank && newLengths[i] == tensor.Lengths[lengthOffset])
+                    {
+                        lengthOffset++;
+                    }
+                    else if (newLengths[i] == 1)
+                    {
+                        if (lengthOffset == tensor.Rank)
+                            origStrides.Add(tensor.Strides[lengthOffset - 1]);
+                        else
+                            origStrides.Insert(i, tensor.Strides[i] * tensor.Lengths[i]);
+                    }
+                    else
+                        ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
+                }
+                strides = origStrides.ToArray();
+            }
+            else
+                strides = [];
+
+            TensorSpan<T> output = new TensorSpan<T>(ref tensor._reference, tensor._shape.LinearLength, newLengths, strides);
+            return output;
+        }
+
+        /// <summary>
+        /// Reshapes the <paramref name="tensor"/> 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="tensor"><see cref="TensorSpan{T}"/> you want to reshape.</param>
+        /// <param name="lengths"><see cref="ReadOnlySpan{T}"/> with the new dimensions.</param>
+        public static ReadOnlyTensorSpan<T> Reshape<T>(in this ReadOnlyTensorSpan<T> tensor, scoped ReadOnlySpan<nint> lengths)
+        {
+            if (tensor.Lengths.SequenceEqual(lengths))
+                return tensor;
+
+            if (!tensor.IsContiguousAndDense && !tensor.Strides.Contains(0))
+            {
+                ThrowHelper.ThrowArgument_CannotReshapeNonContiguousOrDense();
+            }
+
+            nint[] newLengths = lengths.ToArray();
+            // Calculate wildcard info.
+            if (lengths.Contains(-1))
+            {
+                if (lengths.Count(-1) > 1)
+                    ThrowHelper.ThrowArgument_OnlyOneWildcard();
+                nint tempTotal = tensor.FlattenedLength;
+                for (int i = 0; i < lengths.Length; i++)
+                {
+                    if (lengths[i] != -1)
+                    {
+                        tempTotal /= lengths[i];
+                    }
+                }
+                newLengths[lengths.IndexOf(-1)] = tempTotal;
+
+            }
+
+            nint tempLinear = TensorPrimitives.Product(newLengths);
+            if (tempLinear != tensor.FlattenedLength)
+                ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
+
+            nint[] strides;
+
+            // If all our strides are 0 we can reshape however we like and keep all new strides at 0
+            if (!tensor.Strides.ContainsAnyExcept(0))
+            {
+                strides = new nint[newLengths.Length];
+            }
+            // If we contain a 0 stride we can only add dimensions of length 1.
+            else if (tensor.Strides.Contains(0))
+            {
+                List<nint> origStrides = new List<nint>(tensor.Strides.ToArray());
+                int lengthOffset = 0;
+                for (int i = 0; i < newLengths.Length; i++)
+                {
+                    if (lengthOffset < tensor.Rank && newLengths[i] == tensor.Lengths[lengthOffset])
+                        lengthOffset++;
+                    else if (newLengths[i] == 1)
+                    {
+                        if (lengthOffset == tensor.Rank)
+                            origStrides.Add(tensor.Strides[lengthOffset - 1]);
+                        else
+                            origStrides.Insert(i, tensor.Strides[i] * tensor.Lengths[i]);
+                    }
+                    else
+                        ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
+                }
+                strides = origStrides.ToArray();
+            }
+            else
+                strides = [];
+
+            ReadOnlyTensorSpan<T> output = new ReadOnlyTensorSpan<T>(ref tensor._reference, tensor._shape.LinearLength, newLengths, strides);
+            return output;
+        }
+        #endregion
+
+        #region Resize
+        /// <summary>
+        /// Creates a new <see cref="Tensor{T}"/>, allocates new memory, and copies the data from <paramref name="tensor"/>. If the final shape is smaller all data after
+        /// that point is ignored.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="lengths"><see cref="ReadOnlySpan{T}"/> of the desired new shape.</param>
+        public static Tensor<T> Resize<T>(Tensor<T> tensor, ReadOnlySpan<nint> lengths)
+        {
+            nint newSize = TensorPrimitives.Product(lengths);
+            T[] values = tensor.IsPinned ? GC.AllocateArray<T>((int)newSize) : (new T[newSize]);
+            Tensor<T> output = Tensor.Create(values, 0, lengths, []);
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref tensor.AsTensorSpan()._reference, tensor._start), (int)tensor._values.Length - tensor._start);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref output.AsTensorSpan()._reference, (int)output.FlattenedLength);
+            if (newSize >= span.Length)
+                span.CopyTo(ospan);
+            else
+                span.Slice(0, ospan.Length).CopyTo(ospan);
+
+            return output;
+        }
+
+        /// <summary>
+        /// Copies the data from <paramref name="tensor"/>. If the final shape is smaller all data after that point is ignored.
+        /// If the final shape is bigger it is filled with 0s.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="destination">Destination <see cref="TensorSpan{T}"/> with the desired new shape.</param>
+        public static void ResizeTo<T>(scoped in Tensor<T> tensor, in TensorSpan<T> destination)
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref tensor.AsTensorSpan()._reference, tensor._start), (int)tensor._values.Length - tensor._start);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape.LinearLength);
+            if (ospan.Length >= span.Length)
+                span.CopyTo(ospan);
+            else
+                span.Slice(0, ospan.Length).CopyTo(ospan);
+        }
+
+        /// <summary>
+        /// Copies the data from <paramref name="tensor"/>. If the final shape is smaller all data after that point is ignored.
+        /// If the final shape is bigger it is filled with 0s.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="destination">Destination <see cref="TensorSpan{T}"/> with the desired new shape.</param>
+        public static void ResizeTo<T>(scoped in TensorSpan<T> tensor, in TensorSpan<T> destination)
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref tensor._reference, (int)tensor._shape.LinearLength);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape.LinearLength);
+            if (ospan.Length >= span.Length)
+                span.CopyTo(ospan);
+            else
+                span.Slice(0, ospan.Length).CopyTo(ospan);
+        }
+
+        /// <summary>
+        /// Copies the data from <paramref name="tensor"/>. If the final shape is smaller all data after that point is ignored.
+        /// If the final shape is bigger it is filled with 0s.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination">Destination <see cref="TensorSpan{T}"/> with the desired new shape.</param>
+        public static void ResizeTo<T>(scoped in ReadOnlyTensorSpan<T> tensor, in TensorSpan<T> destination)
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref tensor._reference, (int)tensor._shape.LinearLength);
+            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape.LinearLength);
+            if (ospan.Length >= span.Length)
+                span.CopyTo(ospan);
+            else
+                span.Slice(0, ospan.Length).CopyTo(ospan);
+        }
+        #endregion
+
+        #region Reverse
+        /// <summary>
+        /// Reverse the order of elements in the <paramref name="tensor"/>. The shape of the tensor is preserved, but the elements are reordered.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Reverse<T>(in ReadOnlyTensorSpan<T> tensor)
+        {
+            Tensor<T> output = Tensor.Create<T>(tensor.Lengths);
+            ReverseDimension(tensor, output, -1);
+
+            return output;
+        }
+
+        /// <summary>
+        /// Reverse the order of elements in the <paramref name="tensor"/> along the given dimension. The shape of the tensor is preserved, but the elements are reordered.
+        /// <paramref name="dimension"/> defaults to -1 when not provided, which reverses the entire tensor.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="dimension">dimension along which to reverse over. -1 will reverse over all of the dimensions of the left tensor.</param>
+        public static Tensor<T> ReverseDimension<T>(in ReadOnlyTensorSpan<T> tensor, int dimension)
+        {
+            Tensor<T> output = Tensor.Create<T>(tensor.Lengths);
+            ReverseDimension(tensor, output, dimension);
+
+            return output;
+        }
+
+        /// <summary>
+        /// Reverse the order of elements in the <paramref name="tensor"/>. The shape of the tensor is preserved, but the elements are reordered.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Reverse<T>(scoped in ReadOnlyTensorSpan<T> tensor, in TensorSpan<T> destination)
+        {
+            return ref ReverseDimension(tensor, destination, -1);
+        }
+
+        /// <summary>
+        /// Reverse the order of elements in the <paramref name="tensor"/> along the given axis. The shape of the tensor is preserved, but the elements are reordered.
+        /// <paramref name="dimension"/> defaults to -1 when not provided, which reverses the entire span.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        /// <param name="dimension">dimension along which to reverse over. -1 will reverse over all of the dimensions of the left tensor.</param>
+        public static ref readonly TensorSpan<T> ReverseDimension<T>(scoped in ReadOnlyTensorSpan<T> tensor, in TensorSpan<T> destination, int dimension)
+        {
+            // When the dimension is -1, its just a straight reverse copy.
+            if (dimension == -1)
+            {
+                TensorOperation.ValidateCompatibility(tensor, destination);
+                TensorOperation.ReverseInvoke<TensorOperation.CopyTo<T>, T, T>(tensor, destination);
+            }
+            // With any other dimension, we need to copy the data in reverse order based on the provided dimension.
+            else
+            {
+                TensorOperation.ValidateCompatibility(tensor, destination);
+                Span<NRange> srcIndexes = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<NRange> srcIndexesRentedBuffer);
+                Span<NRange> dstIndexes = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<NRange> dstIndexesRentedBuffer);
+
+                for (int i = 0; i < srcIndexes.Length; i++)
+                {
+                    srcIndexes[i] = NRange.All;
+                    dstIndexes[i] = NRange.All;
+                }
+
+                for (int i = (int)tensor.Lengths[dimension]; i > 0; i--)
+                {
+                    srcIndexes[dimension] = new NRange(i - 1, i);
+                    dstIndexes[dimension] = new NRange(tensor.Lengths[dimension] - i, tensor.Lengths[dimension] - i + 1);
+                    TensorOperation.Invoke<TensorOperation.CopyTo<T>, T, T>(tensor.Slice(srcIndexes), destination.Slice(dstIndexes));
+                }
+                srcIndexesRentedBuffer.Dispose();
+                dstIndexesRentedBuffer.Dispose();
+            }
+
+            return ref destination;
+        }
+        #endregion
+
+        #region SequenceEqual
+        /// <summary>
+        /// Determines whether two sequences are equal by comparing the elements using IEquatable{T}.Equals(T).
+        /// </summary>
+        public static bool SequenceEqual<T>(this scoped in TensorSpan<T> tensor, scoped in ReadOnlyTensorSpan<T> other)
+            where T : IEquatable<T>?
+        {
+            return tensor.FlattenedLength == other.FlattenedLength
+                && tensor._shape.LinearLength == other._shape.LinearLength
+                && tensor.Lengths.SequenceEqual(other.Lengths)
+                && MemoryMarshal.CreateReadOnlySpan(in tensor.GetPinnableReference(), (int)tensor._shape.LinearLength).SequenceEqual(MemoryMarshal.CreateReadOnlySpan(in other.GetPinnableReference(), (int)other._shape.LinearLength));
+        }
+
+        /// <summary>
+        /// Determines whether two sequences are equal by comparing the elements using IEquatable{T}.Equals(T).
+        /// </summary>
+        public static bool SequenceEqual<T>(this scoped in ReadOnlyTensorSpan<T> tensor, scoped in ReadOnlyTensorSpan<T> other)
+            where T : IEquatable<T>?
+        {
+            return tensor.FlattenedLength == other.FlattenedLength
+                && tensor._shape.LinearLength == other._shape.LinearLength
+                && tensor.Lengths.SequenceEqual(other.Lengths)
+                && MemoryMarshal.CreateReadOnlySpan(in tensor.GetPinnableReference(), (int)tensor._shape.LinearLength).SequenceEqual(MemoryMarshal.CreateReadOnlySpan(in other.GetPinnableReference(), (int)other._shape.LinearLength));
+        }
+        #endregion
+
+        #region SetSlice
+        /// <summary>
+        /// Sets a slice of the given <paramref name="tensor"/> with the provided <paramref name="values"/> for the given <paramref name="ranges"/>
+        /// </summary>
+        /// <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, in ReadOnlyTensorSpan<T> values, params ReadOnlySpan<NRange> ranges)
+        {
+            tensor.AsTensorSpan().SetSlice(values, ranges);
+            return tensor;
+        }
+
+        /// <summary>
+        /// Sets a slice of the given <paramref name="tensor"/> with the provided <paramref name="values"/> for the given <paramref name="ranges"/>
+        /// </summary>
+        /// <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 ref readonly TensorSpan<T> SetSlice<T>(this in TensorSpan<T> tensor, scoped in ReadOnlyTensorSpan<T> values, params scoped ReadOnlySpan<NRange> ranges)
+        {
+            if (ranges.IsEmpty)
+            {
+                values.CopyTo(tensor);
+            }
+            else
+            {
+                values.CopyTo(tensor.Slice(ranges));
+            }
+            return ref tensor;
+        }
+        #endregion
+
+        #region Split
+        /// <summary>
+        /// Split a <see cref="Tensor{T}"/> into <paramref name="splitCount"/> along the given <paramref name="dimension"/>. If the tensor cannot be split
+        /// evenly on the given <paramref name="dimension"/> an exception is thrown.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="splitCount">How many times to split the <paramref name="tensor"/></param>
+        /// <param name="dimension">The axis to split on.</param>
+        public static Tensor<T>[] Split<T>(scoped in ReadOnlyTensorSpan<T> tensor, int splitCount, nint dimension)
+        {
+            if (tensor.Lengths[(int)dimension] % splitCount != 0)
+                ThrowHelper.ThrowArgument_SplitNotSplitEvenly();
+
+            Tensor<T>[] outputs = new Tensor<T>[splitCount];
+
+            nint totalToCopy = tensor.FlattenedLength / splitCount;
+
+            nint[] newShape = tensor.Lengths.ToArray();
+            nint splitLength = newShape[dimension] / splitCount;
+            newShape[dimension] = splitLength;
+
+            scoped Span<NRange> sliceDims = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<NRange> lengthsRentedBuffer);
+            for (int i = 0; i < sliceDims.Length; i++)
+            {
+                sliceDims[i] = NRange.All;
+            }
+            nint start = 0;
+            for (int i = 0; i < outputs.Length; i++)
+            {
+                sliceDims[(int)dimension] = new NRange(start, start + splitLength);
+                T[] values = new T[(int)totalToCopy];
+                outputs[i] = new Tensor<T>(values, 0, newShape, [], tensor._shape.LinearRankOrder);
+
+                tensor.Slice(sliceDims).CopyTo(outputs[i]);
+                start += splitLength;
+            }
+
+            lengthsRentedBuffer.Dispose();
+            return outputs;
+        }
+        #endregion
+
+        #region Squeeze
+        /// <summary>
+        /// Removes all dimensions of length one from the <paramref name="tensor"/>.
+        /// </summary>
+        /// <param name="tensor">The <see cref="Tensor{T}"/> to remove all dimensions of length 1.</param>
+        public static Tensor<T> Squeeze<T>(this Tensor<T> tensor)
+        {
+            return SqueezeDimension(tensor, -1);
+        }
+
+        /// <summary>
+        /// Removes axis of length one from the <paramref name="tensor"/> for the given <paramref name="dimension"/>.
+        /// If the dimension is not of length one it will throw an exception.
+        /// </summary>
+        /// <param name="tensor">The <see cref="Tensor{T}"/> to remove dimension of length 1.</param>
+        /// <param name="dimension">The dimension to remove.</param>
+        public static Tensor<T> SqueezeDimension<T>(this Tensor<T> tensor, int dimension)
+        {
+            if (dimension >= tensor.Rank || dimension < -1)
+                ThrowHelper.ThrowArgument_AxisLargerThanRank();
+
+            scoped Span<nint> lengths = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<nint> lengthsRentedBuffer);
+            scoped Span<nint> strides = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<nint> stridesRentedBuffer);
+            scoped Span<int> strideOrder = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<int> stridesOrderRentedBuffer);
+            int newRank = 0;
+            int index = 0;
+
+            if (dimension == -1)
+            {
+                int removalCount = tensor.Lengths.Count(1);
+                int removedIndex = 0;
+                Span<int> removed = TensorOperation.RentedBuffer.CreateUninitialized(removalCount, out TensorOperation.RentedBuffer<int> removedRentedBuffer);
+
+                for (int i = 0; i < tensor.Lengths.Length; i++)
+                {
+                    if (tensor.Lengths[i] != 1)
+                    {
+                        lengths[index] = tensor.Lengths[i];
+                        strides[index] = tensor.Strides[i];
+                        newRank++;
+                        strideOrder[index++] = tensor._shape.LinearRankOrder[i];
+                    }
+                    else
+                    {
+                        removed[removedIndex++] = tensor._shape.LinearRankOrder[i];
+                    }
+                }
+                SqueezeHelper(removed, strideOrder);
+                removedRentedBuffer.Dispose();
+            }
+            else
+            {
+                if (tensor.Lengths[dimension] != 1)
+                {
+                    ThrowHelper.ThrowArgument_InvalidSqueezeAxis();
+                }
+                int removed = default;
+                for (int i = 0; i < tensor.Lengths.Length; i++)
+                {
+                    if (i != dimension)
+                    {
+                        lengths[index] = tensor.Lengths[i];
+                        strides[index] = tensor.Strides[i];
+                        newRank++;
+                        strideOrder[index++] = tensor._shape.LinearRankOrder[i];
+                    }
+                    else
+                    {
+                        removed = tensor._shape.LinearRankOrder[i];
+                    }
+                }
+                SqueezeHelper(removed, strideOrder);
+            }
+
+            Tensor<T> output = new Tensor<T>(tensor._values, tensor._start, lengths[..newRank], strides[..newRank], strideOrder[..newRank]);
+
+            lengthsRentedBuffer.Dispose();
+            stridesRentedBuffer.Dispose();
+            stridesOrderRentedBuffer.Dispose();
+
+            return output;
+        }
+
+        /// <summary>
+        /// Removes all dimensions of length one from the <paramref name="tensor"/>.
+        /// </summary>
+        /// <param name="tensor">The <see cref="TensorSpan{T}"/> to remove all dimensions of length 1.</param>
+        public static TensorSpan<T> Squeeze<T>(in this TensorSpan<T> tensor)
+        {
+            return SqueezeDimension(tensor, -1);
+        }
+
+        /// <summary>
+        /// Removes axis of length one from the <paramref name="tensor"/> for the given <paramref name="dimension"/>.
+        /// If the dimension is not of length one it will throw an exception.
+        /// </summary>
+        /// <param name="tensor">The <see cref="TensorSpan{T}"/> to remove dimension of length 1.</param>
+        /// <param name="dimension">The dimension to remove.</param>
+        public static TensorSpan<T> SqueezeDimension<T>(in this TensorSpan<T> tensor, int dimension)
+        {
+            if (dimension >= tensor.Rank || dimension < -1)
+                ThrowHelper.ThrowArgument_AxisLargerThanRank();
+
+            scoped Span<nint> lengths = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<nint> lengthsRentedBuffer);
+            scoped Span<nint> strides = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<nint> stridesRentedBuffer);
+            scoped Span<int> strideOrder = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<int> stridesOrderRentedBuffer);
+            int newRank = 0;
+            int index = 0;
+
+            if (dimension == -1)
+            {
+                int removalCount = tensor.Lengths.Count(1);
+                int removedIndex = 0;
+                Span<int> removed = TensorOperation.RentedBuffer.CreateUninitialized(removalCount, out TensorOperation.RentedBuffer<int> removedRentedBuffer);
+
+                for (int i = 0; i < tensor.Lengths.Length; i++)
+                {
+                    if (tensor.Lengths[i] != 1)
+                    {
+                        lengths[index] = tensor.Lengths[i];
+                        strides[index] = tensor.Strides[i];
+                        newRank++;
+                        strideOrder[index++] = tensor._shape.LinearRankOrder[i];
+                    }
+                    else
+                    {
+                        removed[removedIndex++] = tensor._shape.LinearRankOrder[i];
+                    }
+                }
+                SqueezeHelper(removed, strideOrder);
+                removedRentedBuffer.Dispose();
+            }
+            else
+            {
+                if (tensor.Lengths[dimension] != 1)
+                {
+                    ThrowHelper.ThrowArgument_InvalidSqueezeAxis();
+                }
+                int removed = default;
+                for (int i = 0; i < tensor.Lengths.Length; i++)
+                {
+                    if (i != dimension)
+                    {
+                        lengths[index] = tensor.Lengths[i];
+                        strides[index] = tensor.Strides[i];
+                        newRank++;
+                        strideOrder[index++] = tensor._shape.LinearRankOrder[i];
+                    }
+                    else
+                    {
+                        removed = tensor._shape.LinearRankOrder[i];
+                    }
+                }
+                SqueezeHelper(removed, strideOrder);
+            }
+
+            TensorSpan<T> output = new TensorSpan<T>(ref tensor._reference, tensor._shape.LinearLength, lengths[..newRank], strides[..newRank], strideOrder[..newRank]);
+
+            lengthsRentedBuffer.Dispose();
+            stridesRentedBuffer.Dispose();
+            stridesOrderRentedBuffer.Dispose();
+
+            return output;
+        }
+
+        /// <summary>
+        /// Removes all dimensions of length one from the <paramref name="tensor"/>.
+        /// </summary>
+        /// <param name="tensor">The <see cref="ReadOnlyTensorSpan{T}"/> to remove all dimensions of length 1.</param>
+        public static ReadOnlyTensorSpan<T> Squeeze<T>(in this ReadOnlyTensorSpan<T> tensor)
+        {
+            return SqueezeDimension(tensor, -1);
+        }
+
+        /// <summary>
+        /// Removes axis of length one from the <paramref name="tensor"/> for the given <paramref name="dimension"/>.
+        /// If the dimension is not of length one it will throw an exception.
+        /// </summary>
+        /// <param name="tensor">The <see cref="ReadOnlyTensorSpan{T}"/> to remove dimension of length 1.</param>
+        /// <param name="dimension">The dimension to remove.</param>
+        public static ReadOnlyTensorSpan<T> SqueezeDimension<T>(in this ReadOnlyTensorSpan<T> tensor, int dimension)
+        {
+            if (dimension >= tensor.Rank || dimension < -1)
+                ThrowHelper.ThrowArgument_AxisLargerThanRank();
+
+            scoped Span<nint> lengths = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<nint> lengthsRentedBuffer);
+            scoped Span<nint> strides = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<nint> stridesRentedBuffer);
+            scoped Span<int> strideOrder = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<int> stridesOrderRentedBuffer);
+            int newRank = 0;
+            int index = 0;
+
+            if (dimension == -1)
+            {
+                int removalCount = tensor.Lengths.Count(1);
+                int removedIndex = 0;
+                Span<int> removed = TensorOperation.RentedBuffer.CreateUninitialized(removalCount, out TensorOperation.RentedBuffer<int> removedRentedBuffer);
+
+                for (int i = 0; i < tensor.Lengths.Length; i++)
+                {
+                    if (tensor.Lengths[i] != 1)
+                    {
+                        lengths[index] = tensor.Lengths[i];
+                        strides[index] = tensor.Strides[i];
+                        newRank++;
+                        strideOrder[index++] = tensor._shape.LinearRankOrder[i];
+                    }
+                    else
+                    {
+                        removed[removedIndex++] = tensor._shape.LinearRankOrder[i];
+                    }
+                }
+                SqueezeHelper(removed, strideOrder);
+                removedRentedBuffer.Dispose();
+            }
+            else
+            {
+                if (tensor.Lengths[dimension] != 1)
+                {
+                    ThrowHelper.ThrowArgument_InvalidSqueezeAxis();
+                }
+                int removed = default;
+                for (int i = 0; i < tensor.Lengths.Length; i++)
+                {
+                    if (i != dimension)
+                    {
+                        lengths[index] = tensor.Lengths[i];
+                        strides[index] = tensor.Strides[i];
+                        newRank++;
+                        strideOrder[index++] = tensor._shape.LinearRankOrder[i];
+                    }
+                    else
+                    {
+                        removed = tensor._shape.LinearRankOrder[i];
+                    }
+                }
+                SqueezeHelper(removed, strideOrder);
+            }
+
+            ReadOnlyTensorSpan<T> output =  new ReadOnlyTensorSpan<T>(ref tensor._reference, tensor._shape.LinearLength, lengths[..newRank], strides[..newRank], strideOrder[..newRank]);
+
+            lengthsRentedBuffer.Dispose();
+            stridesRentedBuffer.Dispose();
+            stridesOrderRentedBuffer.Dispose();
+
+            return output;
+        }
+
+        internal static void SqueezeHelper(scoped in Span<int> removed, scoped in Span<int> strideOrder)
+        {
+            for (int i = 0; i < strideOrder.Length; i++)
+            {
+                for (int j = removed.Length - 1; j >= 0; j--)
+                {
+                    if (strideOrder[i] > removed[j])
+                    {
+                        strideOrder[i]--;
+                    }
+                }
+            }
+        }
+
+        internal static void SqueezeHelper(int removed, scoped in Span<int> strideOrder)
+        {
+            for (int i = 0; i < strideOrder.Length; i++)
+            {
+                if (strideOrder[i] > removed)
+                {
+                    strideOrder[i]--;
+                }
+            }
+        }
+        #endregion
+
+        #region Stack
+        /// <summary>
+        /// Join multiple <see cref="Tensor{T}"/> along a new dimension that is added at position 0. All tensors must have the same shape.
+        /// </summary>
+        /// <param name="tensors">Input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Stack<T>(params ReadOnlySpan<Tensor<T>> tensors)
+        {
+            return StackAlongDimension(0, tensors);
+        }
+
+        /// <summary>
+        /// Join multiple <see cref="Tensor{T}"/> along a new dimension. The axis parameter specifies the index of the new dimension. All tensors must have the same shape.
+        /// </summary>
+        /// <param name="tensors">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="dimension">Index of where the new dimension will be.</param>
+        public static Tensor<T> StackAlongDimension<T>(int dimension, params ReadOnlySpan<Tensor<T>> tensors)
+        {
+            if (tensors.Length < 2)
+                ThrowHelper.ThrowArgument_StackTooFewTensors();
+
+            for (int i = 1; i < tensors.Length; i++)
+            {
+                if (!tensors[0].Lengths.SequenceEqual(tensors[i].Lengths))
+                    ThrowHelper.ThrowArgument_StackShapesNotSame();
+            }
+
+            if (dimension < 0)
+                dimension = tensors[0].Rank - dimension;
+
+            Tensor<T>[] outputs = new Tensor<T>[tensors.Length];
+            for (int i = 0; i < tensors.Length; i++)
+            {
+                outputs[i] = Tensor.Unsqueeze(tensors[i], dimension);
+            }
+            return Tensor.ConcatenateOnDimension<T>(dimension, outputs);
+        }
+
+        /// <summary>
+        /// Join multiple <see cref="Tensor{T}"/> along a new dimension that is added at position 0. All tensors must have the same shape.
+        /// </summary>
+        /// <param name="tensors">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Stack<T>(scoped in ReadOnlySpan<Tensor<T>> tensors, in TensorSpan<T> destination)
+        {
+            return ref StackAlongDimension(tensors, destination, 0);
+        }
+
+        /// <summary>
+        /// Join multiple <see cref="Tensor{T}"/> along a new dimension. The axis parameter specifies the index of the new dimension. All tensors must have the same shape.
+        /// </summary>
+        /// <param name="tensors">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="destination"></param>
+        /// <param name="dimension">Index of where the new dimension will be.</param>
+        public static ref readonly TensorSpan<T> StackAlongDimension<T>(scoped ReadOnlySpan<Tensor<T>> tensors, in TensorSpan<T> destination, int dimension)
+        {
+            if (tensors.Length < 2)
+                ThrowHelper.ThrowArgument_StackTooFewTensors();
+
+            for (int i = 1; i < tensors.Length; i++)
+            {
+                if (!tensors[0].Lengths.SequenceEqual(tensors[i].Lengths))
+                    ThrowHelper.ThrowArgument_StackShapesNotSame();
+            }
+
+            if (dimension < 0)
+                dimension = tensors[0].Rank - dimension;
+
+            Tensor<T>[] outputs = new Tensor<T>[tensors.Length];
+            for (int i = 0; i < tensors.Length; i++)
+            {
+                outputs[i] = Tensor.Unsqueeze(tensors[i], dimension);
+            }
+            return ref Tensor.ConcatenateOnDimension<T>(dimension, outputs, destination);
+        }
+        #endregion
+
+        #region ToString
+        /// <summary>
+        /// Creates a <see cref="string"/> representation of the <see cref="TensorSpan{T}"/>."/>
+        /// </summary>
+        /// <param name="tensor">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="tensor"/></returns>
+        public static string ToString<T>(this in TensorSpan<T> tensor, ReadOnlySpan<nint> maximumLengths)
+            => tensor.AsReadOnlyTensorSpan().ToString(maximumLengths);
+
+        /// <summary>
+        /// Creates a <see cref="string"/> representation of the <see cref="ReadOnlyTensorSpan{T}"/>."/>
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="tensor">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 in ReadOnlyTensorSpan<T> tensor, ReadOnlySpan<nint> maximumLengths)
+        {
+            if (maximumLengths.Length != tensor.Rank)
+            {
+                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(tensor));
+            }
+
+            StringBuilder sb = new();
+            ToString(in tensor, maximumLengths, sb);
+            return sb.ToString();
+        }
+
+        internal static void ToString<T>(in ReadOnlyTensorSpan<T> tensor, ReadOnlySpan<nint> maximumLengths, StringBuilder sb, int indentLevel = 0)
+        {
+            Debug.Assert(maximumLengths.Length != tensor.Rank);
+
+            sb.Append(' ', indentLevel * 2);
+            sb.Append('[');
+
+            if (tensor.Rank != 0)
+            {
+                nint length = nint.Max(tensor.Lengths[0], maximumLengths[0]);
+
+                if (tensor.Rank != 1)
+                {
+                    string separator = string.Empty;
+
+                    for (nint i = 0; i < length; i++)
+                    {
+                        sb.AppendLine(separator);
+
+                        TensorShape tmpShape = TensorShape.Create(tensor.Lengths[1..], tensor.Strides[1..]);
+                        ReadOnlyTensorSpan<T> tmpTensor = new ReadOnlyTensorSpan<T>(ref Unsafe.Add(ref tensor._reference, i * tensor.Strides[0]), tmpShape);
+                        ToString(tmpTensor, maximumLengths[1..], sb, indentLevel + 1);
+
+                        separator = ",";
+                    }
+
+                    if (length != tensor.Lengths[0])
+                    {
+                        sb.AppendLine(separator);
+                        sb.Append(' ', indentLevel * 2);
+                        sb.AppendLine("...");
+                    }
+                }
+                else
+                {
+                    string separator = " ";
+
+                    for (nint i = 0; i < length; i++)
+                    {
+                        sb.Append(separator);
+                        sb.Append(Unsafe.Add(ref tensor._reference, i));
+                        separator = ", ";
+                    }
+
+                    if (length != tensor.Lengths[0])
+                    {
+                        sb.Append(separator);
+                        sb.Append("...");
+                    }
+
+                    sb.Append(separator);
+                }
+            }
+            sb.Append(']');
+        }
+
+        /// <summary>
+        /// Creates a <see cref="string"/> representation of the <see cref="Tensor{T}"/>."/>
+        /// </summary>
+        /// <param name="tensor">The <see cref="Span{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="tensor"/></returns>
+        public static string ToString<T>(this Tensor<T> tensor, ReadOnlySpan<nint> maximumLengths)
+            => tensor.AsReadOnlyTensorSpan().ToString(maximumLengths);
+
+        #endregion
+
+        #region Transpose
+        /// <summary>
+        /// Swaps the last two dimensions of the <paramref name="tensor"/> tensor.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
+        public static Tensor<T> Transpose<T>(Tensor<T> tensor)
+        {
+            if (tensor.Lengths.Length < 2)
+                ThrowHelper.ThrowArgument_TransposeTooFewDimensions();
+
+            scoped Span<nint> lengths = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<nint> lengthsRentedBuffer);
+            scoped Span<nint> strides = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<nint> stridesRentedBuffer);
+            scoped Span<int> strideOrder = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank, out TensorOperation.RentedBuffer<int> stridesOrderRentedBuffer);
+
+            tensor.Lengths.CopyTo(lengths);
+            tensor.Strides.CopyTo(strides);
+            tensor._shape.LinearRankOrder.CopyTo(strideOrder);
+
+            nint temp = lengths[^1];
+            lengths[^1] = lengths[^2];
+            lengths[^2] = temp;
+
+            temp = strides[^1];
+            strides[^1] = strides[^2];
+            strides[^2] = temp;
+
+            int tempOrder = strideOrder[^1];
+            strideOrder[^1] = strideOrder[^2];
+            strideOrder[^2] = tempOrder;
+
+            Tensor<T> output = new Tensor<T>(tensor._values, tensor._start, lengths, strides, strideOrder);
+
+            lengthsRentedBuffer.Dispose();
+            stridesRentedBuffer.Dispose();
+            stridesOrderRentedBuffer.Dispose();
+
+            return output;
+        }
+        #endregion
+
+        #region TryBroadcastTo
+        /// <summary>
+        /// Broadcast the data from <paramref name="tensor"/> to the smallest broadcastable shape compatible with <paramref name="destination"/> and stores it in <paramref name="destination"/>
+        /// If the shapes are not compatible, false is returned.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
+        /// <param name="destination">Destination <see cref="TensorSpan{T}"/>.</param>
+        public static bool TryBroadcastTo<T>(this Tensor<T> tensor, in TensorSpan<T> destination)
+        {
+            return tensor.AsReadOnlyTensorSpan().TryBroadcastTo(destination);
+        }
+
+        /// <summary>
+        /// Broadcast the data from <paramref name="tensor"/> to the smallest broadcastable shape compatible with <paramref name="destination"/> and stores it in <paramref name="destination"/>
+        /// If the shapes are not compatible, false is returned.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="TensorSpan{T}"/>.</param>
+        /// <param name="destination">Destination <see cref="TensorSpan{T}"/>.</param>
+        public static bool TryBroadcastTo<T>(in this TensorSpan<T> tensor, in TensorSpan<T> destination)
+        {
+            return tensor.AsReadOnlyTensorSpan().TryBroadcastTo(destination);
+        }
+
+        /// <summary>
+        /// Broadcast the data from <paramref name="tensor"/> to the smallest broadcastable shape compatible with <paramref name="destination"/> and stores it in <paramref name="destination"/>
+        /// If the shapes are not compatible, false is returned.
+        /// </summary>
+        /// <param name="tensor">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination">Destination <see cref="TensorSpan{T}"/>.</param>
+        public static bool TryBroadcastTo<T>(in this ReadOnlyTensorSpan<T> tensor, in TensorSpan<T> destination)
+        {
+            TensorOperation.ValidateCompatibility(tensor, destination);
+            if (!TensorShape.AreCompatible(destination._shape, tensor._shape, false))
+                return false;
+
+            BroadcastTo(tensor, destination);
+            return true;
+        }
+        #endregion
+
+        #region Unsqueeze
+        /// <summary>
+        /// Insert a new dimension of length 1 that will appear at the dimension position.
+        /// </summary>
+        /// <param name="tensor">The <see cref="Tensor{T}"/> to add a dimension of length 1.</param>
+        /// <param name="dimension">The index of the dimension to add.</param>
+        public static Tensor<T> Unsqueeze<T>(this Tensor<T> tensor, int dimension)
+        {
+            if (dimension > tensor.Lengths.Length)
+                ThrowHelper.ThrowArgument_AxisLargerThanRank();
+            if (dimension < 0)
+                dimension = tensor.Rank - dimension;
+
+            scoped Span<nint> newLengths = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank + 1, out TensorOperation.RentedBuffer<nint> lengthsRentedBuffer);
+
+            tensor.Lengths.Slice(0, dimension).CopyTo(newLengths);
+            tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1));
+            newLengths[dimension] = 1;
+
+            Span<nint> newStrides = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank + 1, out TensorOperation.RentedBuffer<nint> stridesRentedBuffer);
+            if (dimension == tensor.Rank)
+            {
+                tensor.Strides.CopyTo(newStrides);
+                newStrides[dimension] = 0;
+            }
+            else
+            {
+                tensor.Strides.Slice(0, dimension).CopyTo(newStrides);
+                tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1));
+                newStrides[dimension] = 0;
+            }
+
+            Tensor<T> output = new Tensor<T>(tensor._values, tensor._start, newLengths, newStrides);
+            lengthsRentedBuffer.Dispose();
+            stridesRentedBuffer.Dispose();
+            return output;
+        }
+
+        /// <summary>
+        /// Insert a new dimension of length 1 that will appear at the dimension position.
+        /// </summary>
+        /// <param name="tensor">The <see cref="TensorSpan{T}"/> to add a dimension of length 1.</param>
+        /// <param name="dimension">The index of the dimension to add.</param>
+        public static TensorSpan<T> Unsqueeze<T>(in this TensorSpan<T> tensor, int dimension)
+        {
+            if (dimension > tensor.Lengths.Length)
+                ThrowHelper.ThrowArgument_AxisLargerThanRank();
+            if (dimension < 0)
+                dimension = tensor.Rank - dimension;
+
+            scoped Span<nint> newLengths = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank + 1, out TensorOperation.RentedBuffer<nint> lengthsRentedBuffer);
+
+            tensor.Lengths.Slice(0, dimension).CopyTo(newLengths);
+            tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1));
+            newLengths[dimension] = 1;
+
+            Span<nint> newStrides = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank + 1, out TensorOperation.RentedBuffer<nint> stridesRentedBuffer);
+            if (dimension == tensor.Rank)
+            {
+                tensor.Strides.CopyTo(newStrides);
+                newStrides[dimension] = 0;
+            }
+            else
+            {
+                tensor.Strides.Slice(0, dimension).CopyTo(newStrides);
+                tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1));
+                newStrides[dimension] = 0;
+            }
+
+            TensorSpan<T> output = new TensorSpan<T>(ref tensor._reference, tensor._shape.LinearLength, newLengths, newStrides);
+            lengthsRentedBuffer.Dispose();
+            stridesRentedBuffer.Dispose();
+            return output;
+        }
+
+        /// <summary>
+        /// Insert a new dimension of length 1 that will appear at the dimension position.
+        /// </summary>
+        /// <param name="tensor">The <see cref="ReadOnlyTensorSpan{T}"/> to add a dimension of length 1.</param>
+        /// <param name="dimension">The index of the dimension to add.</param>
+        public static ReadOnlyTensorSpan<T> Unsqueeze<T>(in this ReadOnlyTensorSpan<T> tensor, int dimension)
+        {
+            if (dimension > tensor.Lengths.Length)
+                ThrowHelper.ThrowArgument_AxisLargerThanRank();
+            if (dimension < 0)
+                dimension = tensor.Rank - dimension;
+
+            scoped Span<nint> newLengths = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank + 1, out TensorOperation.RentedBuffer<nint> lengthsRentedBuffer);
+
+            tensor.Lengths.Slice(0, dimension).CopyTo(newLengths);
+            tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1));
+            newLengths[dimension] = 1;
+
+            Span<nint> newStrides = TensorOperation.RentedBuffer.CreateUninitialized(tensor.Rank + 1, out TensorOperation.RentedBuffer<nint> stridesRentedBuffer);
+            if (dimension == tensor.Rank)
+            {
+                tensor.Strides.CopyTo(newStrides);
+                newStrides[dimension] = 0;
+            }
+            else
+            {
+                tensor.Strides.Slice(0, dimension).CopyTo(newStrides);
+                tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1));
+                newStrides[dimension] = 0;
+            }
+
+            ReadOnlyTensorSpan<T> output = new ReadOnlyTensorSpan<T>(ref tensor._reference, tensor._shape.LinearLength, newLengths, newStrides);
+            lengthsRentedBuffer.Dispose();
+            stridesRentedBuffer.Dispose();
+            return output;
+        }
+        #endregion
+
+        #region TensorPrimitives
+        #region Abs
+        /// <summary>
+        /// 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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the abs of.</param>
+        public static Tensor<T> Abs<T>(in ReadOnlyTensorSpan<T> x)
+            where T : INumberBase<T>
+        {
+            Tensor<T> destination = CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Abs<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the absolute value of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="TensorSpan{T}"/> to take the abs of.</param>
+        /// <param name="destination">The <see cref="TensorSpan{T}"/> destination.</param>
+        public static ref readonly TensorSpan<T> Abs<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : INumberBase<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Abs<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> Acos<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Acos<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <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="x">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Acos<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Acos<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Acosh
+        /// <summary>
+        /// Takes the inverse hyperbolic cosine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> Acosh<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IHyperbolicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Acosh<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <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="x">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Acosh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IHyperbolicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Acosh<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region AcosPi
+        /// <summary>
+        /// 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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> AcosPi<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.AcosPi<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> AcosPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.AcosPi<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Add
+        /// <summary>
+        /// Adds each element of <paramref name="x"/> to each element of <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
+        /// <param name="y">The second <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
+        public static Tensor<T> Add<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Adds <paramref name="y"/> to each element of <paramref name="x"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
+        /// <param name="y">The <typeparamref name="T"/> to add to each element of <paramref name="x"/>.</param>
+        public static Tensor<T> Add<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Adds each element of <paramref name="x"/> to each element of <paramref name="y"/> and returns a new <see cref="ReadOnlyTensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
+        /// <param name="y">The second <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Add<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Adds <paramref name="y"/> to each element of <paramref name="x"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
+        /// <param name="y">The <typeparamref name="T"/> to add to each element of <paramref name="x"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Add<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Add<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Asin
+        /// <summary>
+        /// Takes the inverse sin of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> Asin<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Asin<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the inverse sin of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Asin<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Asin<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Asinh
+        /// <summary>
+        /// Takes the inverse hyperbolic sine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> Asinh<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IHyperbolicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Asinh<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the inverse hyperbolic sine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Asinh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IHyperbolicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Asinh<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region AsinPi
+        /// <summary>
+        /// Takes the inverse hyperbolic sine divided by pi of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> AsinPi<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.AsinPi<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the inverse hyperbolic sine divided by pi of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> AsinPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.AsinPi<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Atan
+        /// <summary>
+        /// Takes the arc tangent of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/></param>
+        public static Tensor<T> Atan<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Atan<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Atan<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Atan<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Atan2
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Atan2<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IFloatingPointIeee754<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Atan2<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Atan2<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Atan2<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Atan2<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IFloatingPointIeee754<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Atan2<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Atan2<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Atan2<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Atan2<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IFloatingPointIeee754<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(y.Lengths);
+            TensorOperation.Invoke<TensorOperation.Atan2<T>, T, T>(y, x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Atan2<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            TensorOperation.ValidateCompatibility(y, destination);
+            TensorOperation.Invoke<TensorOperation.Atan2<T>, T, T>(y, x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Atan2Pi
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Atan2Pi<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IFloatingPointIeee754<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Atan2Pi<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Atan2Pi<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Atan2Pi<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Atan2Pi<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IFloatingPointIeee754<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Atan2Pi<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Atan2Pi<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Atan2Pi<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Atan2Pi<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IFloatingPointIeee754<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(y.Lengths);
+            TensorOperation.Invoke<TensorOperation.Atan2Pi<T>, T, T>(y, x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Atan2Pi<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            TensorOperation.ValidateCompatibility(y, destination);
+            TensorOperation.Invoke<TensorOperation.Atan2Pi<T>, T, T>(y, x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Atanh
+        /// <summary>
+        /// Takes the inverse hyperbolic tangent of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Atanh<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IHyperbolicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Atanh<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the inverse hyperbolic tangent of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Atanh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IHyperbolicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Atanh<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region AtanPi
+        /// <summary>
+        /// Takes the inverse hyperbolic tangent divided by pi of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The input<see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> AtanPi<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.AtanPi<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the inverse hyperbolic tangent divided by pi of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The input<see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> AtanPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.AtanPi<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Average
+        /// <summary>
+        /// Returns the average of the elements in the <paramref name="x"/> tensor.
+        /// </summary>
+        /// <param name="x">The <see cref="TensorSpan{T}"/> to take the mean of.</param>
+        /// <returns><typeparamref name="T"/> representing the mean.</returns>
+        public static T Average<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumberBase<T>
+        {
+            // Get the flattenedLength first so we don't spend time computing if we'll fail due to overflow
+
+            T flattenedLength = T.CreateChecked(x.FlattenedLength);
+            T sum = Sum(x);
+            return sum / flattenedLength;
+        }
+        #endregion
+
+        #region BitwiseAnd
+        /// <summary>
+        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> BitwiseAnd<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> BitwiseAnd<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second value.</param>
+        public static Tensor<T> BitwiseAnd<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second value.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> BitwiseAnd<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.BitwiseAnd<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region BitwiseOr
+        /// <summary>
+        /// Computes the element-wise bitwise of of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> BitwiseOr<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise bitwise of of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> BitwiseOr<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise bitwise or of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second value.</param>
+        public static Tensor<T> BitwiseOr<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise bitwise or of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second value.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> BitwiseOr<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.BitwiseOr<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region CubeRoot
+        /// <summary>
+        /// Computes the element-wise cube root of the input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Cbrt<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IRootFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Cbrt<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise cube root of the input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Cbrt<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IRootFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Cbrt<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Ceiling
+        /// <summary>
+        /// Computes the element-wise ceiling of the input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Ceiling<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IFloatingPoint<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Ceiling<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise ceiling of the input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Ceiling<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IFloatingPoint<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Ceiling<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region ConvertChecked
+        /// <summary>
+        /// Copies <paramref name="source"/> to a new <see cref="ReadOnlyTensorSpan{TTO}"/> converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
+        /// </summary>
+        /// <param name="source">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<TTo> ConvertChecked<TFrom, TTo>(in ReadOnlyTensorSpan<TFrom> source)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            Tensor<TTo> destination = Tensor.CreateUninitialized<TTo>(source.Lengths);
+            TensorOperation.Invoke<TensorOperation.ConvertChecked<TFrom, TTo>, TFrom, TTo>(source, destination);
+            return destination;
+        }
+
+        /// <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{TFrom}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<TTo> ConvertChecked<TFrom, TTo>(scoped in ReadOnlyTensorSpan<TFrom> source, in TensorSpan<TTo> destination)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            TensorOperation.ValidateCompatibility(source, destination);
+            TensorOperation.Invoke<TensorOperation.ConvertChecked<TFrom, TTo>, TFrom, TTo>(source, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region ConvertSaturating
+        /// <summary>
+        /// Copies <paramref name="source"/> to a new <see cref="ReadOnlyTensorSpan{TTO}"/> converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
+        /// </summary>
+        /// <param name="source">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<TTo> ConvertSaturating<TFrom, TTo>(in ReadOnlyTensorSpan<TFrom> source)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            Tensor<TTo> destination = Tensor.CreateUninitialized<TTo>(source.Lengths);
+            TensorOperation.Invoke<TensorOperation.ConvertSaturating<TFrom, TTo>, TFrom, TTo>(source, destination);
+            return destination;
+        }
+
+        /// <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{TFrom}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<TTo> ConvertSaturating<TFrom, TTo>(scoped in ReadOnlyTensorSpan<TFrom> source, in TensorSpan<TTo> destination)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            TensorOperation.ValidateCompatibility(source, destination);
+            TensorOperation.Invoke<TensorOperation.ConvertSaturating<TFrom, TTo>, TFrom, TTo>(source, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region ConvertTruncating
+        /// <summary>
+        /// Copies <paramref name="source"/> to a new <see cref="ReadOnlyTensorSpan{TTO}"/> converting each <typeparamref name="TFrom"/>
+        /// value to a <typeparamref name="TTo"/> value.
+        /// </summary>
+        /// <param name="source">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<TTo> ConvertTruncating<TFrom, TTo>(in ReadOnlyTensorSpan<TFrom> source)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            Tensor<TTo> destination = Tensor.CreateUninitialized<TTo>(source.Lengths);
+            TensorOperation.Invoke<TensorOperation.ConvertTruncating<TFrom, TTo>, TFrom, TTo>(source, destination);
+            return destination;
+        }
+
+        /// <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{TFrom}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<TTo> ConvertTruncating<TFrom, TTo>(scoped in ReadOnlyTensorSpan<TFrom> source, in TensorSpan<TTo> destination)
+            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+            where TTo : INumberBase<TTo>
+        {
+            TensorOperation.ValidateCompatibility(source, destination);
+            TensorOperation.Invoke<TensorOperation.ConvertTruncating<TFrom, TTo>, TFrom, TTo>(source, destination);
+            return ref destination;
+        }
+        #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="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="sign">The number with the associated sign.</param>
+        public static Tensor<T> CopySign<T>(in ReadOnlyTensorSpan<T> x, T sign)
+            where T : INumber<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.CopySign<T>, T, T>(x, sign, destination);
+            return destination;
+        }
+
+        /// <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="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="sign">The <see cref="ReadOnlyTensorSpan{T}"/> with the associated signs.</param>
+        public static Tensor<T> CopySign<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> sign)
+            where T : INumber<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.CopySign<T>, T, T>(x, sign, destination);
+            return destination;
+        }
+
+        /// <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="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="sign">The number with the associated sign.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> CopySign<T>(scoped in ReadOnlyTensorSpan<T> x, T sign, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.CopySign<T>, T, T>(x, sign, destination);
+            return ref destination;
+        }
+
+        /// <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="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="sign">The <see cref="ReadOnlyTensorSpan{T}"/> with the associated signs.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> CopySign<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> sign, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(x, sign, destination);
+            TensorOperation.Invoke<TensorOperation.CopySign<T>, T, T>(x, sign, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Cos
+        /// <summary>
+        /// Takes the cosine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the cosine of.</param>
+        public static Tensor<T> Cos<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Cos<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the cosine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the cosine of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Cos<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Cos<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Cosh
+        /// <summary>
+        /// Takes the hyperbolic cosine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the cosine of.</param>
+        public static Tensor<T> Cosh<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IHyperbolicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Cosh<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the hyperbolic cosine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the cosine of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Cosh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IHyperbolicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Cosh<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region CosineSimilarity
+        /// <summary>
+        /// Compute cosine similarity between <paramref name="x"/> and <paramref name="y"/>.
+        /// </summary>
+        /// <param name="x">The first <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="y">The second <see cref="ReadOnlyTensorSpan{T}"/></param>
+        public static T CosineSimilarity<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IRootFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility<T, T>(x, y);
+            ValueTuple<T, T, T> result = (T.AdditiveIdentity, T.AdditiveIdentity, T.AdditiveIdentity);
+            TensorOperation.Invoke<TensorOperation.CosineSimilarity<T>, T, ValueTuple<T, T, T>>(x, y, ref result);
+            return result.Item1 / (T.Sqrt(result.Item2) * T.Sqrt(result.Item3));
+        }
+        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><typeparamref name="T"/>.CosPi(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians(System.Single)"/> 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>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.CosPi<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <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="x">The input <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="destination"></param>
+        /// <remarks>
+        /// <para>
+        /// This method effectively computes <c><typeparamref name="T"/>.CosPi(<paramref name="x" />[i])</c>.
+        /// </para>
+        /// <para>
+        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians(System.Single)"/> 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 ref readonly TensorSpan<T> CosPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.CosPi<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> DegreesToRadians<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.DegreesToRadians<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> DegreesToRadians<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.DegreesToRadians<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static T Distance<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y)
+            where T : IRootFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, y);
+            T result = T.AdditiveIdentity;
+            TensorOperation.Invoke<TensorOperation.SumOfSquaredDifferences<T>, T, T>(x, y, ref result);
+            return T.Sqrt(result);
+        }
+        #endregion
+
+        #region Divide
+        /// <summary>
+        /// Divides each element of <paramref name="x"/> by <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The divisor</param>
+        public static Tensor<T> Divide<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IDivisionOperators<T, T, T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Divides <paramref name="x"/> by each element of <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result."/>
+        /// </summary>
+        /// <param name="x">The value to be divided.</param>
+        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
+        public static Tensor<T> Divide<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IDivisionOperators<T, T, T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(y.Lengths);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Divides each element of <paramref name="x"/> by its corresponding element in <paramref name="y"/> and returns
+        /// a new <see cref="ReadOnlyTensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to be divided.</param>
+        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
+        public static Tensor<T> Divide<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IDivisionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Divides each element of <paramref name="x"/> by <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The divisor</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Divide<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IDivisionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Divides <paramref name="x"/> by each element of <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result."/>
+        /// </summary>
+        /// <param name="x">The value to be divided.</param>
+        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Divide<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IDivisionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(y, destination);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Divides each element of <paramref name="x"/> by its corresponding element in <paramref name="y"/> and returns
+        /// a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to be divided.</param>
+        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Divide<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IDivisionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Divide<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Dot
+        /// <summary>
+        /// Computes the dot product of two tensors containing numbers.
+        /// </summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static T Dot<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplicativeIdentity<T, T>, IMultiplyOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y);
+            T result = T.AdditiveIdentity;
+            TensorOperation.Invoke<TensorOperation.Dot<T>, T, T>(x, y, ref result);
+            return result;
+        }
+        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Exp<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IExponentialFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Exp<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise result of raising <c>e</c> to the single-precision floating-point number powers in the specified tensor.
+        /// </summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Exp<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IExponentialFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Exp<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Exp10
+        /// <summary>
+        /// Computes the element-wise result of raising 10 to the number powers in the specified tensor.
+        /// </summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Exp10<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IExponentialFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Exp10<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise result of raising 10 to the number powers in the specified tensor.
+        /// </summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Exp10<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IExponentialFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Exp10<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Exp10M1<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IExponentialFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Exp10M1<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise result of raising 10 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Exp10M1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IExponentialFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Exp10M1<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Exp2
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Exp2<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IExponentialFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Exp2<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Exp2<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IExponentialFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Exp2<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Exp2M1<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IExponentialFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Exp2M1<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor, minus one.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Exp2M1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IExponentialFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Exp2M1<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> ExpM1<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IExponentialFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.ExpM1<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise result of raising <c>e</c> to the number powers in the specified tensor, minus 1.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> ExpM1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IExponentialFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.ExpM1<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Floor
+        /// <summary>Computes the element-wise floor of numbers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Floor<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IFloatingPoint<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Floor<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise floor of numbers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Floor<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IFloatingPoint<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Floor<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #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="x">Left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Hypot<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IRootFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Hypot<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <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="x">Left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Hypot<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IRootFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Hypot<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #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="x">Left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Ieee754Remainder<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IFloatingPointIeee754<T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Ieee754Remainder<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <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="x">Left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Ieee754Remainder<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Ieee754Remainder<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Ieee754Remainder<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IFloatingPointIeee754<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Ieee754Remainder<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Ieee754Remainder<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Ieee754Remainder<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Ieee754Remainder<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IFloatingPointIeee754<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(y.Lengths);
+            TensorOperation.Invoke<TensorOperation.Ieee754Remainder<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Ieee754Remainder<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            TensorOperation.ValidateCompatibility(y, destination);
+            TensorOperation.Invoke<TensorOperation.Ieee754Remainder<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region ILogB
+        /// <summary>Computes the element-wise integer logarithm of numbers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<int> ILogB<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IFloatingPointIeee754<T>
+        {
+            Tensor<int> destination = Tensor.CreateUninitialized<int>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.ILogB<T>, T, int>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise integer logarithm of numbers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<int> ILogB<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<int> destination)
+            where T : IFloatingPointIeee754<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.ILogB<T>, T, int>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region IndexOfMax
+        /// <summary>Searches for the index of the largest number in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static nint IndexOfMax<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape.LinearLength);
+            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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static nint IndexOfMaxMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape.LinearLength);
+            return TensorPrimitives.IndexOfMaxMagnitude(span);
+        }
+        #endregion
+
+        #region IndexOfMin
+        /// <summary>Searches for the index of the smallest number in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static nint IndexOfMin<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape.LinearLength);
+            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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static nint IndexOfMinMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape.LinearLength);
+            return TensorPrimitives.IndexOfMinMagnitude(span);
+        }
+        #endregion
+
+        #region LeadingZeroCount
+        /// <summary>
+        /// Computes the element-wise leading zero count of numbers in the specified tensor.
+        /// </summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> LeadingZeroCount<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IBinaryInteger<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.LeadingZeroCount<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise leading zero count of numbers in the specified tensor.
+        /// </summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> LeadingZeroCount<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IBinaryInteger<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.LeadingZeroCount<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Log
+        /// <summary>
+        /// Takes the natural logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the natural logarithm of.</param>
+        public static Tensor<T> Log<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ILogarithmicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Log<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the natural logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the natural logarithm of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Log<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ILogarithmicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Log<T>, T, T>(x, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise logarithm of the numbers in a specified tensor to the specified base in another specified tensor.</summary>
+        /// <param name="x">The first tensor</param>
+        /// <param name="y">The second tensor</param>
+        public static Tensor<T> Log<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : ILogarithmicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Log<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise logarithm of the numbers in a specified tensor to the specified base in another specified tensor.</summary>
+        /// <param name="x">The first tensor</param>
+        /// <param name="y">The second tensor</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> Log<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : ILogarithmicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Log<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise logarithm of the numbers in a specified tensor to the specified base in another specified tensor.</summary>
+        /// <param name="x">The first tensor</param>
+        /// <param name="y">The second tensor</param>
+        public static Tensor<T> Log<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : ILogarithmicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Log<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise logarithm of the numbers in a specified tensor to the specified base in another specified tensor.</summary>
+        /// <param name="x">The first tensor</param>
+        /// <param name="y">The second tensor</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> Log<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : ILogarithmicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Log<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Log10
+        /// <summary>
+        /// Takes the base 10 logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 10 logarithm of.</param>
+        public static Tensor<T> Log10<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ILogarithmicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Log10<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the base 10 logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 10 logarithm of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Log10<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ILogarithmicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Log10<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Log10P1
+        /// <summary>
+        /// Takes the base 10 logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 10 logarithm of.</param>
+        public static Tensor<T> Log10P1<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ILogarithmicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Log10P1<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the base 10 logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 10 logarithm of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Log10P1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ILogarithmicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Log10P1<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Log2
+        /// <summary>
+        /// Takes the base 2 logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 2 logarithm of.</param>
+        public static Tensor<T> Log2<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ILogarithmicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Log2<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the base 2 logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 2 logarithm of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Log2<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ILogarithmicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Log2<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Log2P1
+        /// <summary>
+        /// Takes the base 2 logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 2 logarithm of.</param>
+        public static Tensor<T> Log2P1<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ILogarithmicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Log2P1<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the base 2 logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 2 logarithm of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Log2P1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ILogarithmicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Log2P1<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region LogP1
+        /// <summary>
+        /// Takes the natural logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the natural logarithm of.</param>
+        public static Tensor<T> LogP1<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ILogarithmicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.LogP1<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the natural logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the natural logarithm of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> LogP1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ILogarithmicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.LogP1<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Max
+        /// <summary>Searches for the largest number in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
+        public static T Max<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            T result = x._reference;
+            TensorOperation.Invoke<TensorOperation.Max<T>, T, T>(x, ref result);
+            return result;
+        }
+
+        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> Max<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, out Tensor<T> output);
+            TensorOperation.Invoke<TensorOperation.Max<T>, T, T>(x, y, output);
+            return output;
+        }
+
+        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> Max<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, in destination);
+            TensorOperation.Invoke<TensorOperation.Max<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> Max<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : INumber<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Max<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> Max<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in destination);
+            TensorOperation.Invoke<TensorOperation.Max<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region MaxMagnitude
+        /// <summary>Searches for the number with the largest magnitude in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
+        public static T MaxMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            T result = x._reference;
+            TensorOperation.Invoke<TensorOperation.MaxMagnitude<T>, T, T>(x, ref result);
+            return result;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MaxMagnitude<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.MaxMagnitude<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MaxMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, in destination);
+            TensorOperation.Invoke<TensorOperation.MaxMagnitude<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MaxMagnitude<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : INumber<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.MaxMagnitude<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MaxMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in destination);
+            TensorOperation.Invoke<TensorOperation.MaxMagnitude<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region MaxMagnitudeNumber
+        /// <summary>Searches for the number with the largest magnitude in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
+        public static T MaxMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumberBase<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            T result = x._reference;
+            TensorOperation.Invoke<TensorOperation.MaxMagnitudeNumber<T>, T, T>(x, ref result);
+            return result;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MaxMagnitudeNumber<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.MaxMagnitudeNumber<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MaxMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, in destination);
+            TensorOperation.Invoke<TensorOperation.MaxMagnitudeNumber<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MaxMagnitudeNumber<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : INumber<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.MaxMagnitudeNumber<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MaxMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in destination);
+            TensorOperation.Invoke<TensorOperation.MaxMagnitudeNumber<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region MaxNumber
+        /// <summary>Searches for the largest number in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
+        public static T MaxNumber<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            T result = x._reference;
+            TensorOperation.Invoke<TensorOperation.MaxNumber<T>, T, T>(x, ref result);
+            return result;
+        }
+
+        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MaxNumber<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.MaxNumber<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MaxNumber<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, in destination);
+            TensorOperation.Invoke<TensorOperation.MaxNumber<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MaxNumber<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : INumber<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.MaxNumber<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MaxNumber<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in destination);
+            TensorOperation.Invoke<TensorOperation.MaxNumber<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Min
+        /// <summary>Searches for the largest number in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
+        public static T Min<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            T result = x._reference;
+            TensorOperation.Invoke<TensorOperation.Min<T>, T, T>(x, ref result);
+            return result;
+        }
+
+        /// <summary>Computes the element-wise Minimum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> Min<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, out Tensor<T> output);
+            TensorOperation.Invoke<TensorOperation.Min<T>, T, T>(x, y, output);
+            return output;
+        }
+
+        /// <summary>Computes the element-wise Minimum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> Min<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, in destination);
+            TensorOperation.Invoke<TensorOperation.Min<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise Minimum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> Min<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : INumber<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Min<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise Minimum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> Min<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in destination);
+            TensorOperation.Invoke<TensorOperation.Min<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region MinMagnitude
+        /// <summary>Searches for the number with the largest magnitude in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
+        public static T MinMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            T result = x._reference;
+            TensorOperation.Invoke<TensorOperation.MinMagnitude<T>, T, T>(x, ref result);
+            return result;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MinMagnitude<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.MinMagnitude<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MinMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, in destination);
+            TensorOperation.Invoke<TensorOperation.MinMagnitude<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MinMagnitude<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : INumber<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.MinMagnitude<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MinMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in destination);
+            TensorOperation.Invoke<TensorOperation.MinMagnitude<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region MinMagnitudeNumber
+        /// <summary>Searches for the number with the largest magnitude in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
+        public static T MinMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumberBase<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            T result = x._reference;
+            TensorOperation.Invoke<TensorOperation.MinMagnitudeNumber<T>, T, T>(x, ref result);
+            return result;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MinMagnitudeNumber<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.MinMagnitudeNumber<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MinMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, in destination);
+            TensorOperation.Invoke<TensorOperation.MinMagnitudeNumber<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MinMagnitudeNumber<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : INumber<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.MinMagnitudeNumber<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MinMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in destination);
+            TensorOperation.Invoke<TensorOperation.MinMagnitudeNumber<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region MinNumber
+        /// <summary>Searches for the largest number in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
+        public static T MinNumber<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            if (x.IsEmpty)
+            {
+                ThrowHelper.ThrowArgument_SpansMustBeNonEmpty();
+            }
+
+            T result = x._reference;
+            TensorOperation.Invoke<TensorOperation.MinNumber<T>, T, T>(x, ref result);
+            return result;
+        }
+
+        /// <summary>Computes the element-wise Minimum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MinNumber<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.MinNumber<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise Minimum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MinNumber<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in y, in destination);
+            TensorOperation.Invoke<TensorOperation.MinNumber<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise Minimum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        public static Tensor<T> MinNumber<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : INumber<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.MinNumber<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise Minimum of the numbers in the specified tensors.</summary>
+        /// <param name="x">The first tensor, represented as a span.</param>
+        /// <param name="y">The second tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        public static ref readonly TensorSpan<T> MinNumber<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : INumber<T>
+        {
+            TensorOperation.ValidateCompatibility(in x, in destination);
+            TensorOperation.Invoke<TensorOperation.MinNumber<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Multiply
+        /// <summary>
+        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="y"><typeparamref name="T"/> value to multiply by.</param>
+        public static Tensor<T> Multiply<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            Tensor<T> destination = Tensor.Create<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> 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="x">Left <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
+        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
+        public static Tensor<T> Multiply<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="y"><typeparamref name="T"/> value to multiply by.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Multiply<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> 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="x">Left <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
+        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Multiply<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Multiply<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Negate
+        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
+        public static Tensor<T> Negate<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IUnaryNegationOperators<T, T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Negate<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Negate<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IUnaryNegationOperators<T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Negate<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Norm
+        /// <summary>
+        ///  Takes the norm of the <see cref="ReadOnlyTensorSpan{T}"/> and returns the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the norm of.</param>
+        public static T Norm<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : IRootFunctions<T>
+        {
+            T result = T.AdditiveIdentity;
+            TensorOperation.Invoke<TensorOperation.SumOfSquares<T>, T, T>(x, ref result);
+            return T.Sqrt(result);
+        }
+        #endregion
+
+        #region OnesComplement
+        /// <summary>Computes the element-wise one's complement of numbers in the specified tensor.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
+        public static Tensor<T> OnesComplement<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.OnesComplement<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise one's complement of numbers in the specified tensor.</summary>
+        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> OnesComplement<T>(scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(y, destination);
+            TensorOperation.Invoke<TensorOperation.OnesComplement<T>, T, T>(y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region PopCount
+        /// <summary>Computes the element-wise population count of numbers in the specified tensor.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
+        public static Tensor<T> PopCount<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IBinaryInteger<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.PopCount<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise population count of numbers in the specified tensor.</summary>
+        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> PopCount<T>(scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IBinaryInteger<T>
+        {
+            TensorOperation.ValidateCompatibility(y, destination);
+            TensorOperation.Invoke<TensorOperation.PopCount<T>, T, T>(y, destination);
+            return ref destination;
+        }
+        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second input <see cref="ReadOnlyTensorSpan{T}"/></param>
+        public static Tensor<T> Pow<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IPowerFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Pow<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second input <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Pow<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IPowerFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Pow<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second input</param>
+        public static Tensor<T> Pow<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IPowerFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Pow<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second input <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Pow<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IPowerFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Pow<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second input</param>
+        public static Tensor<T> Pow<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : IPowerFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(y.Lengths);
+            TensorOperation.Invoke<TensorOperation.Pow<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second input <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Pow<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IPowerFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(y, destination);
+            TensorOperation.Invoke<TensorOperation.Pow<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Product
+        /// <summary>Computes the product of all elements in the specified non-empty tensor of numbers.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static T Product<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : IMultiplicativeIdentity<T, T>, IMultiplyOperators<T, T, T>
+        {
+            T destination = T.MultiplicativeIdentity;
+            TensorOperation.Invoke<TensorOperation.Product<T>, T, T>(x, ref destination);
+            return destination;
+        }
+        #endregion
+
+        #region RadiansToDegrees
+        /// <summary>Computes the element-wise conversion of each number of radians in the specified tensor to degrees.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> RadiansToDegrees<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.RadiansToDegrees<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise conversion of each number of radians in the specified tensor to degrees.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> RadiansToDegrees<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.RadiansToDegrees<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Reciprocal
+        /// <summary>Computes the element-wise reciprocal of numbers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Reciprocal<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IFloatingPoint<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Reciprocal<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise reciprocal of numbers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Reciprocal<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IFloatingPoint<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Reciprocal<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region RootN
+        /// <summary>Computes the element-wise n-th root of the values in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="n">The degree of the root to be computed, represented as a scalar.</param>
+        public static Tensor<T> RootN<T>(in ReadOnlyTensorSpan<T> x, int n)
+            where T : IRootFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.RootN<T>, T, T>(x, n, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise n-th root of the values in the specified tensor.</summary>
+        /// <param name="x">The tensor, represented as a span.</param>
+        /// <param name="destination">The destination tensor, represented as a span.</param>
+        /// <param name="n">The degree of the root to be computed, represented as a scalar.</param>
+        public static ref readonly TensorSpan<T> RootN<T>(scoped in ReadOnlyTensorSpan<T> x, int n, in TensorSpan<T> destination)
+            where T : IRootFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.RootN<T>, T, T>(x, n, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region RotateLeft
+        /// <summary>Computes the element-wise rotation left of numbers in the specified tensor by the specified rotation amount.</summary>
+        /// <param name="x">The tensor</param>
+        /// <param name="rotateAmount">The number of bits to rotate, represented as a scalar.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        public static Tensor<T> RotateLeft<T>(in ReadOnlyTensorSpan<T> x, int rotateAmount)
+            where T : IBinaryInteger<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.RotateLeft<T>, T, T>(x, rotateAmount, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise rotation left of numbers in the specified tensor by the specified rotation amount.</summary>
+        /// <param name="x">The tensor</param>
+        /// <param name="rotateAmount">The number of bits to rotate, represented as a scalar.</param>
+        /// <param name="destination"></param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        public static ref readonly TensorSpan<T> RotateLeft<T>(scoped in ReadOnlyTensorSpan<T> x, int rotateAmount, in TensorSpan<T> destination)
+            where T : IBinaryInteger<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.RotateLeft<T>, T, T>(x, rotateAmount, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region RotateRight
+        /// <summary>Computes the element-wise rotation right of numbers in the specified tensor by the specified rotation amount.</summary>
+        /// <param name="x">The tensor</param>
+        /// <param name="rotateAmount">The number of bits to rotate, represented as a scalar.</param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        public static Tensor<T> RotateRight<T>(in ReadOnlyTensorSpan<T> x, int rotateAmount)
+            where T : IBinaryInteger<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.RotateRight<T>, T, T>(x, rotateAmount, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise rotation right of numbers in the specified tensor by the specified rotation amount.</summary>
+        /// <param name="x">The tensor</param>
+        /// <param name="rotateAmount">The number of bits to rotate, represented as a scalar.</param>
+        /// <param name="destination"></param>
+        /// <exception cref="ArgumentException">Destination is too short.</exception>
+        public static ref readonly TensorSpan<T> RotateRight<T>(scoped in ReadOnlyTensorSpan<T> x, int rotateAmount, in TensorSpan<T> destination)
+            where T : IBinaryInteger<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.RotateRight<T>, T, T>(x, rotateAmount, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Round
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Round<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IFloatingPoint<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Round<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Round<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IFloatingPoint<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Round<T>, T, T>(x, destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="digits"></param>
+        /// <param name="mode"></param>
+        public static Tensor<T> Round<T>(in ReadOnlyTensorSpan<T> x, int digits, MidpointRounding mode)
+            where T : IFloatingPoint<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Round<T>, T, Tuple<int, MidpointRounding>, T>(x, Tuple.Create(digits, mode), destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="digits"></param>
+        /// <param name="mode"></param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Round<T>(scoped in ReadOnlyTensorSpan<T> x, int digits, MidpointRounding mode, in TensorSpan<T> destination)
+            where T : IFloatingPoint<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Round<T>, T, Tuple<int, MidpointRounding>, T>(x, Tuple.Create(digits, mode), in destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="digits"></param>
+        public static Tensor<T> Round<T>(in ReadOnlyTensorSpan<T> x, int digits)
+            where T : IFloatingPoint<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Round<T>, T, Tuple<int, MidpointRounding>, T>(x, Tuple.Create(digits, MidpointRounding.ToEven), destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="digits"></param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Round<T>(scoped in ReadOnlyTensorSpan<T> x, int digits, in TensorSpan<T> destination)
+            where T : IFloatingPoint<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Round<T>, T, Tuple<int, MidpointRounding>, T>(x, Tuple.Create(digits, MidpointRounding.ToEven), in destination);
+            return ref destination;
+        }
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="mode"></param>
+        public static Tensor<T> Round<T>(in ReadOnlyTensorSpan<T> x, MidpointRounding mode)
+            where T : IFloatingPoint<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Round<T>, T, Tuple<int, MidpointRounding>, T>(x, Tuple.Create(0, mode), destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="mode"></param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Round<T>(scoped in ReadOnlyTensorSpan<T> x, MidpointRounding mode, in TensorSpan<T> destination)
+            where T : IFloatingPoint<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Round<T>, T, Tuple<int, MidpointRounding>, T>(x, Tuple.Create(0, mode), in destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Sigmoid
+        /// <summary>Computes the element-wise sigmoid function on the specified non-empty tensor of numbers.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Sigmoid<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IExponentialFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Sigmoid<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise sigmoid function on the specified non-empty tensor of numbers.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Sigmoid<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IExponentialFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Sigmoid<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Sin
+        /// <summary>
+        /// Takes the sin of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> Sin<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Sin<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the sin of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Sin<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Sin<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Sinh
+        /// <summary>Computes the element-wise hyperbolic sine of each radian angle in the specified tensor.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> Sinh<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IHyperbolicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Sinh<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise hyperbolic sine of each radian angle in the specified tensor.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Sinh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IHyperbolicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Sinh<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> SinPi<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.SinPi<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise sine of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> SinPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.SinPi<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region SoftMax
+        /// <summary>Computes the softmax function over the specified non-empty tensor of numbers.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> SoftMax<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IExponentialFunctions<T>
+        {
+            T sumExp = T.AdditiveIdentity;
+            TensorOperation.Invoke<TensorOperation.SumExp<T>, T, T>(x, ref sumExp);
+
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.SoftMax<T>, T, T>(x, sumExp, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the softmax function over the specified non-empty tensor of numbers.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> SoftMax<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IExponentialFunctions<T>
+        {
+            T sumExp = T.AdditiveIdentity;
+            TensorOperation.Invoke<TensorOperation.SumExp<T>, T, T>(x, ref sumExp);
+
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.SoftMax<T>, T, T>(x, sumExp, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Sqrt
+        /// <summary>
+        /// Takes the square root of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the square root of.</param>
+        public static Tensor<T> Sqrt<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IRootFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Sqrt<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Takes the square root of each element of the <paramref name="x"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the square root of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Sqrt<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IRootFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Sqrt<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region StdDev
+        /// <summary>
+        /// Returns the standard deviation of the elements in the <paramref name="x"/> tensor.
+        /// </summary>
+        /// <param name="x">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>(in ReadOnlyTensorSpan<T> x)
+            where T : IRootFunctions<T>
+        {
+            T mean = Average(x);
+            T result = T.AdditiveIdentity;
+            TensorOperation.Invoke<TensorOperation.SumOfSquaredDifferences<T>, T, T>(x, mean, ref result);
+            T variance = result / T.CreateChecked(x.FlattenedLength);
+            return T.Sqrt(variance);
+
+        }
+        #endregion
+
+        #region Subtract
+        /// <summary>
+        /// Subtracts <paramref name="y"/> from each element of <paramref name="x"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The <typeparamref name="T"/> to subtract.</param>
+        public static Tensor<T> Subtract<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Subtracts each element of <paramref name="y"/> from <paramref name="x"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <typeparamref name="T"/> to be subtracted from.</param>
+        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> of values to subtract.</param>
+        public static Tensor<T> Subtract<T>(T x, in ReadOnlyTensorSpan<T> y)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            Tensor<T> destination = CreateUninitialized<T>(y.Lengths);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Subtracts each element of <paramref name="x"/> from <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> with values to be subtracted from.</param>
+        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> with values to subtract.</param>
+        public static Tensor<T> Subtract<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Subtracts <paramref name="y"/> from each element of <paramref name="x"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> with values to be subtracted from.</param>
+        /// <param name="y">The <typeparamref name="T"/> value to subtract.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Subtract<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Subtracts each element of <paramref name="y"/> from <paramref name="x"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <typeparamref name="T"/> value to be subtracted from.</param>
+        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> values to subtract.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Subtract<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(y, destination);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Subtracts each element of <paramref name="x"/> from <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to be subtracted from.</param>
+        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/>of values to subtract.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Subtract<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : ISubtractionOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Subtract<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Sum
+        /// <summary>
+        /// Sums the elements of the specified tensor.
+        /// </summary>
+        /// <param name="x">Tensor to sum</param>
+        /// <returns></returns>
+        public static T Sum<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            T destination = T.AdditiveIdentity;
+            TensorOperation.Invoke<TensorOperation.Sum<T>, T, T>(x, ref destination);
+            return destination;
+        }
+        #endregion
+
+        #region SumOfSquares
+        /// <summary>
+        /// Sums the squared elements of the specified tensor.
+        /// </summary>
+        /// <param name="x">Tensor to sum squares of</param>
+        /// <returns></returns>
+        internal static T SumOfSquares<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T>
+        {
+            T result = T.AdditiveIdentity;
+            TensorOperation.Invoke<TensorOperation.SumOfSquares<T>, T, T>(x, ref result);
+            return result;
+        }
+        #endregion
+
+        #region Tan
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> Tan<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Tan<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Tan<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Tan<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Tanh
+        /// <summary>Computes the element-wise hyperbolic tangent of each radian angle in the specified tensor.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> Tanh<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IHyperbolicFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Tanh<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise hyperbolic tangent of each radian angle in the specified tensor.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Tanh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IHyperbolicFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Tanh<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        public static Tensor<T> TanPi<T>(in ReadOnlyTensorSpan<T> x)
+            where T : ITrigonometricFunctions<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.TanPi<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise tangent of the value in the specified tensor that has been multiplied by Pi.</summary>
+        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> TanPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : ITrigonometricFunctions<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.TanPi<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region TrailingZeroCount
+        /// <summary>Computes the element-wise trailing zero count of numbers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> TrailingZeroCount<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IBinaryInteger<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.TrailingZeroCount<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise trailing zero count of numbers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> TrailingZeroCount<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IBinaryInteger<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.TrailingZeroCount<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Truncate
+        /// <summary>Computes the element-wise truncation of numbers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Truncate<T>(in ReadOnlyTensorSpan<T> x)
+            where T : IFloatingPoint<T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Truncate<T>, T, T>(x, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise truncation of numbers in the specified tensor.</summary>
+        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Truncate<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
+            where T : IFloatingPoint<T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Truncate<T>, T, T>(x, destination);
+            return ref destination;
+        }
+        #endregion
+
+        #region Xor
+        /// <summary>Computes the element-wise XOR of numbers in the specified tensors.</summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        public static Tensor<T> Xor<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, out Tensor<T> destination);
+            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>Computes the element-wise XOR of numbers in the specified tensors.</summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Xor<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, y, destination);
+            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
+            return ref destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise Xor of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second value.</param>
+        public static Tensor<T> Xor<T>(in ReadOnlyTensorSpan<T> x, T y)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            Tensor<T> destination = Tensor.CreateUninitialized<T>(x.Lengths);
+            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
+            return destination;
+        }
+
+        /// <summary>
+        /// Computes the element-wise Xor of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
+        /// </summary>
+        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
+        /// <param name="y">The second value.</param>
+        /// <param name="destination"></param>
+        public static ref readonly TensorSpan<T> Xor<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
+            where T : IBitwiseOperators<T, T, T>
+        {
+            TensorOperation.ValidateCompatibility(x, destination);
+            TensorOperation.Invoke<TensorOperation.Xor<T>, T, T>(x, y, destination);
+            return ref destination;
         }
+        #endregion
+        #endregion
     }
 }
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
deleted file mode 100644
index 6b9dbec121b207..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs
+++ /dev/null
@@ -1,7183 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Buffers;
-using static System.Runtime.InteropServices.JavaScript.JSType;
-using System.Security.Cryptography;
-using System.Runtime.Serialization;
-using System.Diagnostics.CodeAnalysis;
-
-#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.
-
-namespace System.Numerics.Tensors
-{
-    /// <summary>
-    /// Provides methods for tensor operations.
-    /// </summary>
-    [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
-    public static partial class Tensor
-    {
-        #region AsReadOnlySpan
-        /// <summary>
-        /// Extension method to more easily create a TensorSpan from an array.
-        /// </summary>
-        /// <typeparam name="T">The type of the elements in the array</typeparam>
-        /// <param name="array">The <see cref="Array"/> with the data</param>
-        /// <param name="lengths">The shape for the <see cref="TensorSpan{T}"/></param>
-        /// <returns></returns>
-        public static ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan<T>(this T[]? array, params scoped ReadOnlySpan<nint> lengths) => new(array, 0, lengths, default);
-        #endregion
-
-        #region AsTensorSpan
-        /// <summary>
-        /// Extension method to more easily create a TensorSpan from an array.
-        /// </summary>
-        /// <typeparam name="T">The type of the elements in the array</typeparam>
-        /// <param name="array">The <see cref="Array"/> with the data</param>
-        /// <param name="lengths">The shape for the <see cref="TensorSpan{T}"/></param>
-        /// <returns></returns>
-        public static TensorSpan<T> AsTensorSpan<T>(this T[]? array, params scoped ReadOnlySpan<nint> lengths) => new(array, 0, lengths, default);
-        #endregion
-
-        #region Broadcast
-        /// <summary>
-        /// Broadcast the data from <paramref name="source"/> to the smallest broadcastable shape compatible with <paramref name="lengthsSource"/>. Creates a new <see cref="Tensor{T}"/> and allocates new memory.
-        /// </summary>
-        /// <param name="source">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="lengthsSource">Other <see cref="Tensor{T}"/> to make shapes broadcastable.</param>
-        public static Tensor<T> Broadcast<T>(scoped in ReadOnlyTensorSpan<T> source, scoped in ReadOnlyTensorSpan<T> lengthsSource)
-        {
-            return Broadcast(source, lengthsSource.Lengths);
-        }
-
-        /// <summary>
-        /// Broadcast the data from <paramref name="source"/> to the new shape <paramref name="lengths"/>. Creates a new <see cref="Tensor{T}"/> and allocates new memory.
-        /// If the shape of the <paramref name="source"/> is not compatible with the new shape, an exception is thrown.
-        /// </summary>
-        /// <param name="source">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="lengths"><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>(scoped in ReadOnlyTensorSpan<T> source, scoped ReadOnlySpan<nint> lengths)
-        {
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(source.Lengths, lengths);
-
-            ReadOnlyTensorSpan<T> intermediate = LazyBroadcast(source, newSize);
-            Tensor<T> output = Tensor.CreateUninitialized<T>(intermediate.Lengths);
-            intermediate.FlattenTo(MemoryMarshal.CreateSpan(ref output._values[0], (int)output.FlattenedLength));
-            return output;
-        }
-        #endregion
-
-        #region BroadcastTo
-        /// <summary>
-        /// Broadcast the data from <paramref name="source"/> to <paramref name="destination"/>.
-        /// </summary>
-        /// <param name="source">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static void BroadcastTo<T>(this Tensor<T> source, in TensorSpan<T> destination)
-        {
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(source.Lengths, destination.Lengths);
-            if (!destination.Lengths.SequenceEqual(newSize))
-                ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible();
-
-            ReadOnlyTensorSpan<T> intermediate = LazyBroadcast(source, newSize);
-            intermediate.FlattenTo(MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength));
-        }
-
-        /// <summary>
-        /// Broadcast the data from <paramref name="source"/> to <paramref name="destination"/>.
-        /// </summary>
-        /// <param name="source">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="destination">Other <see cref="TensorSpan{T}"/> to make shapes broadcastable.</param>
-        public static void BroadcastTo<T>(in this TensorSpan<T> source, in TensorSpan<T> destination)
-        {
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(source.Lengths, destination.Lengths);
-            if (!destination.Lengths.SequenceEqual(newSize))
-                ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible();
-
-            ReadOnlyTensorSpan<T> intermediate = LazyBroadcast(source, newSize);
-            intermediate.FlattenTo(MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength));
-        }
-
-        /// <summary>
-        /// Broadcast the data from <paramref name="source"/> to <paramref name="destination"/>.
-        /// </summary>
-        /// <param name="source">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static void BroadcastTo<T>(in this ReadOnlyTensorSpan<T> source, in TensorSpan<T> destination)
-        {
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(source.Lengths, destination.Lengths);
-            if (!destination.Lengths.SequenceEqual(newSize))
-                ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible();
-
-            ReadOnlyTensorSpan<T> intermediate = LazyBroadcast(source, newSize);
-            intermediate.FlattenTo(MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength));
-        }
-
-        // 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> LazyBroadcast<T>(in TensorSpan<T> input, ReadOnlySpan<nint> shape)
-        {
-            if (input.Lengths.SequenceEqual(shape))
-                return new TensorSpan<T>(ref input._reference, shape, input.Strides, input._shape._memoryLength);
-
-            if (!TensorHelpers.IsBroadcastableTo(input.Lengths, shape))
-                ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible();
-
-            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._shape._memoryLength);
-
-            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 ReadOnlyTensorSpan<T> LazyBroadcast<T>(in ReadOnlyTensorSpan<T> input, ReadOnlySpan<nint> shape)
-        {
-            if (input.Lengths.SequenceEqual(shape))
-                return new TensorSpan<T>(ref input._reference, shape, input.Strides, input._shape._memoryLength);
-
-            if (!TensorHelpers.IsBroadcastableTo(input.Lengths, shape))
-                ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible();
-
-            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._shape._memoryLength);
-
-            return output;
-        }
-
-        // Lazy/non-copy broadcasting, internal only for now.
-        /// <summary>
-        /// Broadcast the data from <paramref name="input"/> to the new shape <paramref name="lengths"/>. 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="Tensor{T}"/>.</param>
-        /// <param name="lengths"><see cref="ReadOnlySpan{T}"/> of the desired new shape.</param>
-        /// <exception cref="ArgumentException">Thrown when the shapes are not broadcast compatible.</exception>
-        internal static Tensor<T> LazyBroadcast<T>(Tensor<T> input, ReadOnlySpan<nint> lengths)
-        {
-            if (input.Lengths.SequenceEqual(lengths))
-                return new Tensor<T>(input._values, lengths, input._memoryOffset, isPinned: false);
-
-            if (!TensorHelpers.IsBroadcastableTo(input.Lengths, lengths))
-                ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible();
-
-            nint newSize = TensorSpanHelpers.CalculateTotalLength(lengths);
-
-            if (newSize == input.FlattenedLength)
-                return Reshape(input, lengths);
-
-            nint[] intermediateShape = TensorHelpers.GetIntermediateShape(input.Lengths, lengths.Length);
-            nint[] strides = new nint[lengths.Length];
-
-            nint stride = 1;
-
-            for (int i = strides.Length - 1; i >= 0; i--)
-            {
-                if ((intermediateShape[i] == 1 && lengths[i] != 1) || (intermediateShape[i] == 1 && lengths[i] == 1))
-                    strides[i] = 0;
-                else
-                {
-                    strides[i] = stride;
-                    stride *= intermediateShape[i];
-                }
-            }
-
-            Tensor<T> output = new Tensor<T>(input._values, lengths, strides, input._memoryOffset);
-
-            return output;
-        }
-        #endregion
-
-        #region Concatenate
-        /// <summary>
-        /// Join a sequence of tensors along an existing axis.
-        /// </summary>
-        /// <param name="tensors">The tensors must have the same shape, except in the dimension corresponding to axis (the first, by default).</param>
-        public static Tensor<T> Concatenate<T>(params scoped ReadOnlySpan<Tensor<T>> tensors)
-        {
-            return ConcatenateOnDimension(0, tensors);
-        }
-
-        /// <summary>
-        /// Join a sequence of tensors along an existing axis.
-        /// </summary>
-        /// <param name="tensors">The tensors must have the same shape, except in the dimension corresponding to axis (the first, by default).</param>
-        /// <param name="dimension">The axis along which the tensors will be joined. If axis is -1, arrays are flattened before use. Default is 0.</param>
-        public static Tensor<T> ConcatenateOnDimension<T>(int dimension, params scoped ReadOnlySpan<Tensor<T>> tensors)
-        {
-            if (tensors.Length < 2)
-                ThrowHelper.ThrowArgument_ConcatenateTooFewTensors();
-
-            if (dimension < -1 || dimension > tensors[0].Rank)
-                ThrowHelper.ThrowArgument_InvalidAxis();
-
-            // Calculate total space needed.
-            nint totalLength = 0;
-            for (int i = 0; i < tensors.Length; i++)
-                totalLength += TensorSpanHelpers.CalculateTotalLength(tensors[i].Lengths);
-
-            nint sumOfAxis = 0;
-            // If axis != -1, make sure all dimensions except the one to concatenate on match.
-            if (dimension != -1)
-            {
-                sumOfAxis = tensors[0].Lengths[dimension];
-                for (int i = 1; i < tensors.Length; i++)
-                {
-                    if (tensors[0].Rank != tensors[i].Rank)
-                        ThrowHelper.ThrowArgument_InvalidConcatenateShape();
-                    for (int j = 0; j < tensors[0].Rank; j++)
-                    {
-                        if (j != dimension)
-                        {
-                            if (tensors[0].Lengths[j] != tensors[i].Lengths[j])
-                                ThrowHelper.ThrowArgument_InvalidConcatenateShape();
-                        }
-                    }
-                    sumOfAxis += tensors[i].Lengths[dimension];
-                }
-            }
-
-            Tensor<T> tensor;
-            if (dimension == -1)
-            {
-                tensor = Tensor.Create<T>([totalLength]);
-            }
-            else
-            {
-                nint[] lengths = new nint[tensors[0].Rank];
-                tensors[0].Lengths.CopyTo(lengths);
-                lengths[dimension] = sumOfAxis;
-                tensor = Tensor.Create<T>(lengths);
-            }
-
-            ConcatenateOnDimension(dimension, tensors, tensor);
-            return tensor;
-        }
-
-        /// <summary>
-        /// Join a sequence of tensors along an existing axis.
-        /// </summary>
-        /// <param name="tensors">The tensors must have the same shape, except in the dimension corresponding to axis (the first, by default).</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Concatenate<T>(scoped ReadOnlySpan<Tensor<T>> tensors, in TensorSpan<T> destination)
-        {
-            return ref ConcatenateOnDimension(0, tensors, destination);
-        }
-
-        /// <summary>
-        /// Join a sequence of tensors along an existing axis.
-        /// </summary>
-        /// <param name="tensors">The tensors must have the same shape, except in the dimension corresponding to axis (the first, by default).</param>
-        /// <param name="dimension">The axis along which the tensors will be joined. If axis is -1, arrays are flattened before use. Default is 0.</param>
-        /// <param name="destination"></param>
-
-        public static ref readonly TensorSpan<T> ConcatenateOnDimension<T>(int dimension, scoped ReadOnlySpan<Tensor<T>> tensors, in TensorSpan<T> destination)
-        {
-            if (tensors.Length < 2)
-                ThrowHelper.ThrowArgument_ConcatenateTooFewTensors();
-
-            if (dimension < -1 || dimension > tensors[0].Rank)
-                ThrowHelper.ThrowArgument_InvalidAxis();
-
-            // Calculate total space needed.
-            nint totalLength = 0;
-            for (int i = 0; i < tensors.Length; i++)
-                totalLength += TensorSpanHelpers.CalculateTotalLength(tensors[i].Lengths);
-
-            nint sumOfAxis = 0;
-            // If axis != -1, make sure all dimensions except the one to concatenate on match.
-            if (dimension != -1)
-            {
-                sumOfAxis = tensors[0].Lengths[dimension];
-                for (int i = 1; i < tensors.Length; i++)
-                {
-                    if (tensors[0].Rank != tensors[i].Rank)
-                        ThrowHelper.ThrowArgument_InvalidConcatenateShape();
-                    for (int j = 0; j < tensors[0].Rank; j++)
-                    {
-                        if (j != dimension)
-                        {
-                            if (tensors[0].Lengths[j] != tensors[i].Lengths[j])
-                                ThrowHelper.ThrowArgument_InvalidConcatenateShape();
-                        }
-                    }
-                    sumOfAxis += tensors[i].Lengths[dimension];
-                }
-
-                // Make sure the destination tensor has the correct shape.
-                nint[] lengths = new nint[tensors[0].Rank];
-                tensors[0].Lengths.CopyTo(lengths);
-                lengths[dimension] = sumOfAxis;
-
-                if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, lengths))
-                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-            }
-            Span<T> dstSpan = MemoryMarshal.CreateSpan(ref destination._reference, (int)totalLength);
-            nint valuesCopied = 0;
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (tensors[0].Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(tensors[0].Rank);
-                curIndex = curIndexArray.AsSpan(0, tensors[0].Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[tensors[0].Rank];
-            }
-            curIndex.Clear();
-
-            nint srcIndex;
-            nint copyLength;
-
-            while (valuesCopied < totalLength)
-            {
-                for (int i = 0; i < tensors.Length; i++)
-                {
-                    srcIndex = TensorSpanHelpers.ComputeLinearIndex(curIndex, tensors[i].Strides, tensors[i].Lengths);
-                    copyLength = CalculateCopyLength(tensors[i].Lengths, dimension);
-                    Span<T> srcSpan = MemoryMarshal.CreateSpan(ref tensors[i]._values[srcIndex], (int)copyLength);
-                    TensorSpanHelpers.Memmove(dstSpan, srcSpan, copyLength, valuesCopied);
-                    valuesCopied += copyLength;
-                }
-                TensorSpanHelpers.AdjustIndexes(dimension - 1, 1, curIndex, tensors[0].Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-
-        private static nint CalculateCopyLength(ReadOnlySpan<nint> lengths, int startingAxis)
-        {
-            // When starting axis is -1 we want all the data at once same as if starting axis is 0
-            if (startingAxis == -1)
-                startingAxis = 0;
-            nint length = 1;
-            for (int i = startingAxis; i < lengths.Length; i++)
-            {
-                length *= lengths[i];
-            }
-            return length;
-        }
-        #endregion
-
-        #region Equals
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> for equality. If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size
-        /// before they are compared. It returns a <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <returns>A <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not.</returns>
-        public static Tensor<bool> Equals<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IEqualityOperators<T, T, bool>
-        {
-            Tensor<bool> result;
-            if (TensorHelpers.AreLengthsTheSame(x, y))
-            {
-                result = Tensor.Create<bool>(x.Lengths, false);
-            }
-            else
-            {
-                nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-                result = Tensor.Create<bool>(newSize, false);
-            }
-
-            Equals(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> for equality. If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size
-        /// before they are compared. It returns a <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="destination"></param>
-        /// <returns>A <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> Equals<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
-            where T : IEqualityOperators<T, T, bool>
-        {
-            scoped ReadOnlyTensorSpan<T> left;
-            scoped ReadOnlyTensorSpan<T> right;
-            if (TensorHelpers.AreLengthsTheSame(x, y))
-            {
-                if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, x.Lengths))
-                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-                left = x;
-                right = y;
-            }
-            else
-            {
-                nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-                if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, newSize))
-                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-                left = LazyBroadcast(x, newSize);
-                right = LazyBroadcast(y, newSize);
-            }
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (right.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(right.Rank);
-                curIndex = curIndexArray.AsSpan(0, right.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[right.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < left.FlattenedLength; i++)
-            {
-                destination[curIndex] = left[curIndex] == right[curIndex];
-                TensorSpanHelpers.AdjustIndexes(right.Rank - 1, 1, curIndex, right.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> for equality. If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size
-        /// before they are compared. It returns a <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second value to compare.</param>
-        /// <returns>A <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not.</returns>
-        public static Tensor<bool> Equals<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IEqualityOperators<T, T, bool>
-        {
-            Tensor<bool> result = Tensor.Create<bool>(x.Lengths, false);
-            Equals(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> for equality. If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size
-        /// before they are compared. It returns a <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second value to compare.</param>
-        /// <param name="destination"></param>
-        /// <returns>A <see cref="TensorSpan{Boolean}"/> where the value is true if the elements are equal and false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> Equals<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<bool> destination)
-            where T : IEqualityOperators<T, T, bool>
-        {
-            if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, x.Lengths))
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                destination[curIndex] = x[curIndex] == y;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-        #endregion
-
-        #region EqualsAll
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are equal to <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are eqaul to <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are equal to <paramref name="y"/>.</returns>
-        public static bool EqualsAll<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IEqualityOperators<T, T, bool>
-        {
-
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-            ReadOnlyTensorSpan<T> broadcastedLeft = LazyBroadcast(x, newSize);
-            ReadOnlyTensorSpan<T> broadcastedRight = LazyBroadcast(y, newSize);
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (broadcastedLeft.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(broadcastedRight.Rank);
-                curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[broadcastedRight.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < broadcastedLeft.FlattenedLength; i++)
-            {
-                if (broadcastedLeft[curIndex] != broadcastedRight[curIndex])
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(broadcastedRight.Rank - 1, 1, curIndex, broadcastedRight.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are equal to <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are eqaul to <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are equal to <paramref name="y"/>.</returns>
-        public static bool EqualsAll<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IEqualityOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                if (x[curIndex] != y)
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-        #endregion
-
-        #region EqualsAny
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are equal to <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are equal to <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are equal to <paramref name="y"/>.</returns>
-        public static bool EqualsAny<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IEqualityOperators<T, T, bool>
-        {
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-            ReadOnlyTensorSpan<T> broadcastedLeft = LazyBroadcast(x, newSize);
-            ReadOnlyTensorSpan<T> broadcastedRight = LazyBroadcast(y, newSize);
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (broadcastedRight.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(broadcastedRight.Lengths.Length);
-                curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[broadcastedRight.Lengths.Length];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < broadcastedLeft.FlattenedLength; i++)
-            {
-                if (broadcastedLeft[curIndex] == broadcastedRight[curIndex])
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(broadcastedRight.Rank - 1, 1, curIndex, broadcastedRight.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are equal to <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are equal to <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are equal to <paramref name="y"/>.</returns>
-        public static bool EqualsAny<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IEqualityOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                if (x[curIndex] == y)
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-        #endregion
-
-        #region FilteredUpdate
-        /// <summary>
-        /// Updates the <paramref name="tensor"/> tensor with the <paramref name="value"/> where the <paramref name="filter"/> is true.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="filter">Input filter where if the index is true then it will update the <paramref name="tensor"/>.</param>
-        /// <param name="value">Value to update in the <paramref name="tensor"/>.</param>
-        public static ref readonly TensorSpan<T> FilteredUpdate<T>(in this TensorSpan<T> tensor, scoped in ReadOnlyTensorSpan<bool> filter, T value)
-        {
-            if (filter.Lengths.Length != tensor.Lengths.Length)
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(filter));
-
-            Span<T> srcSpan = MemoryMarshal.CreateSpan(ref tensor._reference, (int)tensor._shape._memoryLength);
-            Span<bool> filterSpan = MemoryMarshal.CreateSpan(ref filter._reference, (int)tensor._shape._memoryLength);
-
-            for (int i = 0; i < filterSpan.Length; i++)
-            {
-                if (filterSpan[i])
-                {
-                    srcSpan[i] = value;
-                }
-            }
-
-            return ref tensor;
-        }
-
-        /// <summary>
-        /// Updates the <paramref name="tensor"/> tensor with the <paramref name="values"/> where the <paramref name="filter"/> is true.
-        /// If dimensions are not the same an exception is thrown.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="filter">Input filter where if the index is true then it will update the <paramref name="tensor"/>.</param>
-        /// <param name="values">Values to update in the <paramref name="tensor"/>.</param>
-        public static ref readonly TensorSpan<T> FilteredUpdate<T>(in this TensorSpan<T> tensor, scoped in ReadOnlyTensorSpan<bool> filter, scoped in ReadOnlyTensorSpan<T> values)
-        {
-            if (filter.Lengths.Length != tensor.Lengths.Length)
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(filter));
-            if (values.Rank != 1)
-                ThrowHelper.ThrowArgument_1DTensorRequired(nameof(values));
-
-            Span<T> dstSpan = MemoryMarshal.CreateSpan(ref tensor._reference, (int)tensor._shape._memoryLength);
-            Span<bool> filterSpan = MemoryMarshal.CreateSpan(ref filter._reference, (int)tensor._shape._memoryLength);
-            Span<T> valuesSpan = MemoryMarshal.CreateSpan(ref values._reference, (int)values._shape._memoryLength);
-
-            int index = 0;
-            for (int i = 0; i < filterSpan.Length; i++)
-            {
-                if (filterSpan[i])
-                {
-                    dstSpan[i] = valuesSpan[index++];
-                }
-            }
-
-            return ref tensor;
-        }
-        #endregion
-
-        #region GreaterThan
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/> and
-        /// false if they are not.</returns>
-        public static Tensor<bool> GreaterThan<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result;
-            if (TensorHelpers.AreLengthsTheSame(x, y))
-            {
-                result = Tensor.Create<bool>(x.Lengths, false);
-            }
-            else
-            {
-                nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-                result = Tensor.Create<bool>(newSize, false);
-            }
-
-            GreaterThan(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="destination"></param>
-        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/> and
-        /// false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> GreaterThan<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped ReadOnlyTensorSpan<T> left;
-            scoped ReadOnlyTensorSpan<T> right;
-            if (TensorHelpers.AreLengthsTheSame(x, y))
-            {
-                if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, x.Lengths))
-                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-                left = x;
-                right = y;
-            }
-            else
-            {
-                nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-                if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, newSize))
-                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-                left = LazyBroadcast(x, newSize);
-                right = LazyBroadcast(y, newSize);
-            }
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (right.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(right.Rank);
-                curIndex = curIndexArray.AsSpan(0, right.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[right.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < left.FlattenedLength; i++)
-            {
-                destination[curIndex] = left[curIndex] > right[curIndex];
-                TensorSpanHelpers.AdjustIndexes(right.Rank - 1, 1, curIndex, right.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="ReadOnlyTensorSpan{T}"/> to see which elements are greater than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static Tensor<bool> GreaterThan<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result = Tensor.Create<bool>(x.Lengths, false);
-            GreaterThan(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="ReadOnlyTensorSpan{T}"/> to see which elements are greater than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <param name="destination"></param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> GreaterThan<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, x.Lengths))
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                destination[curIndex] = x[curIndex] > y;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Compares <paramref name="x"/> to see which elements are greater than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static Tensor<bool> GreaterThan<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result = Tensor.Create<bool>(y.Lengths, false);
-            GreaterThan(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares <paramref name="x"/> to see which elements are greater than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <param name="destination"></param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> GreaterThan<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, y.Lengths))
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < y.FlattenedLength; i++)
-            {
-                destination[curIndex] = x > y[curIndex];
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-        #endregion
-
-        #region GreaterThanOrEqual
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are greater than or equal to <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/> and
-        /// false if they are not.</returns>
-        public static Tensor<bool> GreaterThanOrEqual<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result;
-            if (TensorHelpers.AreLengthsTheSame(x, y))
-            {
-                result = Tensor.Create<bool>(x.Lengths, false);
-            }
-            else
-            {
-                nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-                result = Tensor.Create<bool>(newSize, false);
-            }
-
-            GreaterThanOrEqual(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are greater than or equal to <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="destination"></param>
-        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/> and
-        /// false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> GreaterThanOrEqual<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped ReadOnlyTensorSpan<T> left;
-            scoped ReadOnlyTensorSpan<T> right;
-            if (TensorHelpers.AreLengthsTheSame(x, y))
-            {
-                if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, x.Lengths))
-                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-                left = x;
-                right = y;
-            }
-            else
-            {
-                nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-                if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, newSize))
-                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-                left = LazyBroadcast(x, newSize);
-                right = LazyBroadcast(y, newSize);
-            }
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (right.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(right.Rank);
-                curIndex = curIndexArray.AsSpan(0, right.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[right.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < left.FlattenedLength; i++)
-            {
-                destination[curIndex] = left[curIndex] >= right[curIndex];
-                TensorSpanHelpers.AdjustIndexes(right.Rank - 1, 1, curIndex, right.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="ReadOnlyTensorSpan{T}"/> to see which elements are greater than or equal to <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static Tensor<bool> GreaterThanOrEqual<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result = Tensor.Create<bool>(x.Lengths, false);
-            GreaterThanOrEqual(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="ReadOnlyTensorSpan{T}"/> to see which elements are greater than or equal to <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <param name="destination"></param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> GreaterThanOrEqual<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, x.Lengths))
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                destination[curIndex] = x[curIndex] >= y;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Compares <paramref name="x"/> to see which elements are greater than or equal to <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static Tensor<bool> GreaterThanOrEqual<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result = Tensor.Create<bool>(y.Lengths, false);
-            GreaterThanOrEqual(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares <paramref name="x"/> to see which elements are greater than or equal to <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <param name="destination"></param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are greater than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> GreaterThanOrEqual<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, y.Lengths))
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < y.FlattenedLength; i++)
-            {
-                destination[curIndex] = x >= y[curIndex];
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-        #endregion
-
-        #region GreaterThanAny
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
-        public static bool GreaterThanAny<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-            ReadOnlyTensorSpan<T> broadcastedLeft = LazyBroadcast(x, newSize);
-            ReadOnlyTensorSpan<T> broadcastedRight = LazyBroadcast(y, newSize);
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (broadcastedRight.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(broadcastedRight.Lengths.Length);
-                curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[broadcastedRight.Lengths.Length];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < broadcastedLeft.FlattenedLength; i++)
-            {
-                if (broadcastedLeft[curIndex] > broadcastedRight[curIndex])
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(broadcastedRight.Rank - 1, 1, curIndex, broadcastedRight.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
-        public static bool GreaterThanAny<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                if (x[curIndex] > y)
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="y"/> are greater than <paramref name="x"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are greater than <paramref name="x"/>.
-        /// </summary>
-        /// <param name="y">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="x">Value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are greater than <paramref name="x"/>.</returns>
-        public static bool GreaterThanAny<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < y.FlattenedLength; i++)
-            {
-                if (x > y[curIndex])
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-        #endregion
-
-        #region GreaterThanOrEqualAny
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
-        public static bool GreaterThanOrEqualAny<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-            ReadOnlyTensorSpan<T> broadcastedLeft = LazyBroadcast(x, newSize);
-            ReadOnlyTensorSpan<T> broadcastedRight = LazyBroadcast(y, newSize);
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (broadcastedRight.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(broadcastedRight.Lengths.Length);
-                curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[broadcastedRight.Lengths.Length];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < broadcastedLeft.FlattenedLength; i++)
-            {
-                if (broadcastedLeft[curIndex] >= broadcastedRight[curIndex])
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(broadcastedRight.Rank - 1, 1, curIndex, broadcastedRight.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
-        public static bool GreaterThanOrEqualAny<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                if (x[curIndex] >= y)
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="y"/> are greater than <paramref name="x"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are greater than <paramref name="x"/>.
-        /// </summary>
-        /// <param name="y">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="x">Value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are greater than <paramref name="x"/>.</returns>
-        public static bool GreaterThanOrEqualAny<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < y.FlattenedLength; i++)
-            {
-                if (x >= y[curIndex])
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-        #endregion
-
-        #region GreaterThanAll
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
-        public static bool GreaterThanAll<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-            ReadOnlyTensorSpan<T> broadcastedLeft = LazyBroadcast(x, newSize);
-            ReadOnlyTensorSpan<T> broadcastedRight = LazyBroadcast(y, newSize);
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (broadcastedLeft.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(broadcastedRight.Rank);
-                curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[broadcastedRight.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < broadcastedLeft.FlattenedLength; i++)
-            {
-                if (broadcastedLeft[curIndex] <= broadcastedRight[curIndex])
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(broadcastedRight.Rank - 1, 1, curIndex, broadcastedRight.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
-        public static bool GreaterThanAll<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                if (x[curIndex] <= y)
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="y"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are greater than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are greater than <paramref name="y"/>.</returns>
-        public static bool GreaterThanAll<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < y.FlattenedLength; i++)
-            {
-                if (x <= y[curIndex])
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-        #endregion
-
-        #region GreaterThanOrEqualAll
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
-        public static bool GreaterThanOrEqualAll<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-            ReadOnlyTensorSpan<T> broadcastedLeft = LazyBroadcast(x, newSize);
-            ReadOnlyTensorSpan<T> broadcastedRight = LazyBroadcast(y, newSize);
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (broadcastedLeft.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(broadcastedRight.Rank);
-                curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[broadcastedRight.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < broadcastedLeft.FlattenedLength; i++)
-            {
-                if (broadcastedLeft[curIndex] < broadcastedRight[curIndex])
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(broadcastedRight.Rank - 1, 1, curIndex, broadcastedRight.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are greater than <paramref name="y"/>.</returns>
-        public static bool GreaterThanOrEqualAll<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                if (x[curIndex] < y)
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="y"/> are greater than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are greater than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are greater than <paramref name="y"/>.</returns>
-        public static bool GreaterThanOrEqualAll<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < y.FlattenedLength; i++)
-            {
-                if (x < y[curIndex])
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-        #endregion
-
-        #region LessThan
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/> and
-        /// false if they are not.</returns>
-        public static Tensor<bool> LessThan<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result;
-            if (TensorHelpers.AreLengthsTheSame(x, y))
-            {
-                result = Tensor.Create<bool>(x.Lengths, false);
-            }
-            else
-            {
-                nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-                result = Tensor.Create<bool>(newSize, false);
-            }
-
-            LessThan(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="destination"></param>
-        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/> and
-        /// false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> LessThan<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped ReadOnlyTensorSpan<T> left;
-            scoped ReadOnlyTensorSpan<T> right;
-            if (TensorHelpers.AreLengthsTheSame(x, y))
-            {
-                if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, x.Lengths))
-                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-                left = x;
-                right = y;
-            }
-            else
-            {
-                nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-                if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, newSize))
-                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-                left = LazyBroadcast(x, newSize);
-                right = LazyBroadcast(y, newSize);
-            }
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (right.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(right.Rank);
-                curIndex = curIndexArray.AsSpan(0, right.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[right.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < left.FlattenedLength; i++)
-            {
-                destination[curIndex] = left[curIndex] < right[curIndex];
-                TensorSpanHelpers.AdjustIndexes(right.Rank - 1, 1, curIndex, right.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static Tensor<bool> LessThan<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result = Tensor.Create<bool>(x.Lengths, false);
-            LessThan(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <param name="destination"></param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> LessThan<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, x.Lengths))
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                destination[curIndex] = x[curIndex] < y;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static Tensor<bool> LessThan<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result = Tensor.Create<bool>(y.Lengths, false);
-            LessThan(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <param name="destination"></param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> LessThan<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, y.Lengths))
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < y.FlattenedLength; i++)
-            {
-                destination[curIndex] = x < y[curIndex];
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-        #endregion
-
-        #region LessThanOrEqual
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/> and
-        /// false if they are not.</returns>
-        public static Tensor<bool> LessThanOrEqual<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result;
-            if (TensorHelpers.AreLengthsTheSame(x, y))
-            {
-                result = Tensor.Create<bool>(x.Lengths, false);
-            }
-            else
-            {
-                nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-                result = Tensor.Create<bool>(newSize, false);
-            }
-
-            LessThanOrEqual(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see which elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="destination"></param>
-        /// <returns>A <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/> and
-        /// false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> LessThanOrEqual<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped ReadOnlyTensorSpan<T> left;
-            scoped ReadOnlyTensorSpan<T> right;
-            if (TensorHelpers.AreLengthsTheSame(x, y))
-            {
-                if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, x.Lengths))
-                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-                left = x;
-                right = y;
-            }
-            else
-            {
-                nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-                if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, newSize))
-                    ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-                left = LazyBroadcast(x, newSize);
-                right = LazyBroadcast(y, newSize);
-            }
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (right.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(right.Rank);
-                curIndex = curIndexArray.AsSpan(0, right.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[right.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < left.FlattenedLength; i++)
-            {
-                destination[curIndex] = left[curIndex] <= right[curIndex];
-                TensorSpanHelpers.AdjustIndexes(right.Rank - 1, 1, curIndex, right.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static Tensor<bool> LessThanOrEqual<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result = Tensor.Create<bool>(x.Lengths, false);
-            LessThanOrEqual(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <param name="destination"></param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> LessThanOrEqual<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, x.Lengths))
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                destination[curIndex] = x[curIndex] <= y;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static Tensor<bool> LessThanOrEqual<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            Tensor<bool> result = Tensor.Create<bool>(y.Lengths, false);
-            LessThanOrEqual(x, y, result);
-            return result;
-        }
-
-        /// <summary>
-        /// Compares the elements of a <see cref="Tensor{T}"/> to see which elements are less than <paramref name="y"/>.
-        /// It returns a <see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not."/>
-        /// </summary>
-        /// <param name="x"><see cref="Tensor{T}"/> to compare.</param>
-        /// <param name="y"><typeparamref name="T"/> to compare against <paramref name="x"/>.</param>
-        /// <param name="destination"></param>
-        /// <returns><see cref="Tensor{Boolean}"/> where the value is true if the elements in <paramref name="x"/> are less than <paramref name="y"/>
-        /// and false if they are not.</returns>
-        public static ref readonly TensorSpan<bool> LessThanOrEqual<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<bool> destination)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, y.Lengths))
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < y.FlattenedLength; i++)
-            {
-                destination[curIndex] = x <= y[curIndex];
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return ref destination;
-        }
-        #endregion
-
-        #region LessThanAny
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
-        public static bool LessThanAny<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-            ReadOnlyTensorSpan<T> broadcastedLeft = LazyBroadcast(x, newSize);
-            ReadOnlyTensorSpan<T> broadcastedRight = LazyBroadcast(y, newSize);
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (broadcastedRight.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(broadcastedRight.Lengths.Length);
-                curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[broadcastedRight.Lengths.Length];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < broadcastedLeft.FlattenedLength; i++)
-            {
-                if (broadcastedLeft[curIndex] < broadcastedRight[curIndex])
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(broadcastedRight.Rank - 1, 1, curIndex, broadcastedRight.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
-        public static bool LessThanAny<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                if (x[curIndex] < y)
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="y"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are less than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First value to compare.</param>
-        /// <param name="y">Second value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are less than <paramref name="y"/>.</returns>
-        public static bool LessThanAny<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < y.FlattenedLength; i++)
-            {
-                if (x < y[curIndex])
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-        #endregion
-
-        #region LessThanOrEqualAny
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
-        public static bool LessThanOrEqualAny<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-            ReadOnlyTensorSpan<T> broadcastedLeft = LazyBroadcast(x, newSize);
-            ReadOnlyTensorSpan<T> broadcastedRight = LazyBroadcast(y, newSize);
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (broadcastedRight.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(broadcastedRight.Lengths.Length);
-                curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[broadcastedRight.Lengths.Length];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < broadcastedLeft.FlattenedLength; i++)
-            {
-                if (broadcastedLeft[curIndex] <= broadcastedRight[curIndex])
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(broadcastedRight.Rank - 1, 1, curIndex, broadcastedRight.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
-        public static bool LessThanOrEqualAny<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                if (x[curIndex] <= y)
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if any elements of <paramref name="y"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are less than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First value to compare.</param>
-        /// <param name="y">Second value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if any elements in <paramref name="y"/> are less than <paramref name="y"/>.</returns>
-        public static bool LessThanOrEqualAny<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i <= y.FlattenedLength; i++)
-            {
-                if (x <= y[curIndex])
-                    return true;
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return false;
-        }
-        #endregion
-
-        #region LessThanAll
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
-        public static bool LessThanAll<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-            ReadOnlyTensorSpan<T> broadcastedLeft = LazyBroadcast(x, newSize);
-            ReadOnlyTensorSpan<T> broadcastedRight = LazyBroadcast(y, newSize);
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (broadcastedRight.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(broadcastedRight.Lengths.Length);
-                curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[broadcastedRight.Lengths.Length];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < broadcastedLeft.FlattenedLength; i++)
-            {
-                if (broadcastedLeft[curIndex] >= broadcastedRight[curIndex])
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(broadcastedRight.Rank - 1, 1, curIndex, broadcastedRight.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
-        public static bool LessThanAll<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                if (x[curIndex] >= y)
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="y"/> are less than <paramref name="x"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are less than <paramref name="x"/>.
-        /// </summary>
-        /// <param name="y">First value to compare.</param>
-        /// <param name="x">Second value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are less than <paramref name="x"/>.</returns>
-        public static bool LessThanAll<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < y.FlattenedLength; i++)
-            {
-                if (x >= y[curIndex])
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-        #endregion
-
-        #region LessThanOrEqualAll
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second <see cref="ReadOnlyTensorSpan{T}"/> to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
-        public static bool LessThanOrEqualAll<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(x.Lengths, y.Lengths);
-            ReadOnlyTensorSpan<T> broadcastedLeft = LazyBroadcast(x, newSize);
-            ReadOnlyTensorSpan<T> broadcastedRight = LazyBroadcast(y, newSize);
-
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (broadcastedRight.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(broadcastedRight.Lengths.Length);
-                curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[broadcastedRight.Lengths.Length];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < broadcastedLeft.FlattenedLength; i++)
-            {
-                if (broadcastedLeft[curIndex] > broadcastedRight[curIndex])
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(broadcastedRight.Rank - 1, 1, curIndex, broadcastedRight.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="x"/> are less than <paramref name="y"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">First <see cref="ReadOnlyTensorSpan{T}"/> to compare.</param>
-        /// <param name="y">Second value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="x"/> are less than <paramref name="y"/>.</returns>
-        public static bool LessThanOrEqualAll<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (x.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(x.Rank);
-                curIndex = curIndexArray.AsSpan(0, x.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[x.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < x.FlattenedLength; i++)
-            {
-                if (x[curIndex] > y)
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-
-        /// <summary>
-        /// Compares the elements of two <see cref="ReadOnlyTensorSpan{T}"/> to see if all elements of <paramref name="y"/> are less than <paramref name="x"/>.
-        /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared.
-        /// It returns a <see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are less than <paramref name="x"/>.
-        /// </summary>
-        /// <param name="y">First value to compare.</param>
-        /// <param name="x">Second value to compare against.</param>
-        /// <returns><see cref="bool"/> where the value is true if all elements in <paramref name="y"/> are less than <paramref name="x"/>.</returns>
-        public static bool LessThanOrEqualAll<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IComparisonOperators<T, T, bool>
-        {
-            scoped Span<nint> curIndex;
-            nint[]? curIndexArray;
-
-            if (y.Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexArray = ArrayPool<nint>.Shared.Rent(y.Rank);
-                curIndex = curIndexArray.AsSpan(0, y.Rank);
-            }
-            else
-            {
-                curIndexArray = null;
-                curIndex = stackalloc nint[y.Rank];
-            }
-            curIndex.Clear();
-
-            for (int i = 0; i < y.FlattenedLength; i++)
-            {
-                if (x > y[curIndex])
-                    return false;
-                TensorSpanHelpers.AdjustIndexes(y.Rank - 1, 1, curIndex, y.Lengths);
-            }
-
-            if (curIndexArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexArray);
-
-            return true;
-        }
-        #endregion
-
-        #region Permute
-
-        /// <summary>
-        /// Swaps the dimensions of the <paramref name="tensor"/> tensor according to the <paramref name="dimensions"/> parameter.
-        /// If <paramref name="tensor"/> is a 1D tensor, it will return <paramref name="tensor"/>. Otherwise it creates a new <see cref="Tensor{T}"/>
-        /// with the new axis ordering by allocating new memory.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="Tensor{T}"/></param>
-        /// <param name="dimensions"><see cref="ReadOnlySpan{T}"/> with the new axis ordering.</param>
-        public static Tensor<T> PermuteDimensions<T>(this Tensor<T> tensor, params ReadOnlySpan<int> dimensions)
-        {
-            if (tensor.Rank == 1)
-            {
-                return tensor;
-            }
-            else
-            {
-                T[] values = tensor.IsPinned ? GC.AllocateArray<T>((int)tensor._flattenedLength) : (new T[tensor._flattenedLength]);
-                nint[] lengths = new nint[tensor.Rank];
-                Tensor<T> outTensor;
-                TensorSpan<T> ospan;
-                TensorSpan<T> ispan;
-                ReadOnlySpan<int> permutation;
-
-                if (dimensions.IsEmpty)
-                {
-                    int[] tempPermutation = new int[tensor.Rank];
-                    for (int i = 0; i < tensor.Rank; i++)
-                    {
-                        lengths[i] = tensor._lengths[tensor.Rank - 1 - i];
-                        tempPermutation[i] = tensor.Rank - 1 - i;
-                    }
-
-                    permutation = tempPermutation;
-                }
-                else
-                {
-                    if (dimensions.Length != tensor.Lengths.Length)
-                        ThrowHelper.ThrowArgument_PermuteAxisOrder();
-                    for (int i = 0; i < lengths.Length; i++)
-                        lengths[i] = tensor.Lengths[dimensions[i]];
-                    permutation = dimensions.ToArray();
-                }
-                outTensor = new Tensor<T>(values, lengths, Array.Empty<nint>(), tensor._memoryOffset, tensor._isPinned);
-
-                ospan = outTensor.AsTensorSpan();
-                ispan = tensor.AsTensorSpan();
-
-                scoped Span<nint> indexes;
-                nint[]? indicesArray;
-                scoped Span<nint> permutedIndices;
-                nint[]? permutedIndicesArray;
-                if (outTensor.Rank > 6)
-                {
-                    indicesArray = ArrayPool<nint>.Shared.Rent(outTensor.Rank);
-                    indexes = indicesArray.AsSpan(0, outTensor.Rank);
-                    indexes.Clear();
-
-                    permutedIndicesArray = ArrayPool<nint>.Shared.Rent(outTensor.Rank);
-                    permutedIndices = permutedIndicesArray.AsSpan(0, outTensor.Rank);
-                    permutedIndices.Clear();
-                }
-                else
-                {
-                    indicesArray = null;
-                    indexes = stackalloc nint[outTensor.Rank];
-                    permutedIndicesArray = null;
-                    permutedIndices = stackalloc nint[outTensor.Rank];
-                }
-
-                for (int i = 0; i < tensor._flattenedLength; i++)
-                {
-                    TensorHelpers.PermuteIndices(indexes, permutedIndices, permutation);
-                    ospan[permutedIndices] = ispan[indexes];
-                    TensorSpanHelpers.AdjustIndexes(outTensor.Rank - 1, 1, indexes, tensor._lengths);
-                }
-
-                if (indicesArray != null && permutedIndicesArray != null)
-                {
-                    ArrayPool<nint>.Shared.Return(indicesArray);
-                    ArrayPool<nint>.Shared.Return(permutedIndicesArray);
-                }
-
-                return outTensor;
-            }
-        }
-        #endregion
-
-        #region Reshape
-        /// <summary>
-        /// Reshapes the <paramref name="tensor"/> 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="tensor"><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> tensor, params ReadOnlySpan<nint> lengths)
-        {
-            if (tensor.Lengths.SequenceEqual(lengths))
-                return tensor;
-
-            if (!TensorHelpers.IsContiguousAndDense<T>(tensor) && !tensor.Strides.Contains(0))
-            {
-                ThrowHelper.ThrowArgument_CannotReshapeNonContiguousOrDense();
-            }
-
-            nint[] arrLengths = lengths.ToArray();
-            // Calculate wildcard info.
-            if (lengths.Contains(-1))
-            {
-                if (lengths.Count(-1) > 1)
-                    ThrowHelper.ThrowArgument_OnlyOneWildcard();
-                nint tempTotal = tensor._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 != tensor.FlattenedLength)
-                ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
-
-            nint[] strides;
-
-            // If we contain a 0 stride we can only add dimensions of length 1.
-            if (tensor.Strides.Contains(0))
-            {
-                List<nint> origStrides = new List<nint>(tensor.Strides.ToArray());
-                int lengthOffset = 0;
-                for (int i = 0; i < arrLengths.Length; i++)
-                {
-                    if (lengthOffset < tensor.Rank && arrLengths[i] == tensor.Lengths[lengthOffset])
-                        lengthOffset++;
-                    else if (arrLengths[i] == 1)
-                    {
-                        if (lengthOffset == tensor.Rank)
-                            origStrides.Add(tensor.Strides[lengthOffset - 1]);
-                        else
-                            origStrides.Insert(i, tensor.Strides[i] * tensor.Lengths[i]);
-                    }
-                    else
-                        ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
-                }
-                strides = origStrides.ToArray();
-            }
-            else
-                strides = TensorSpanHelpers.CalculateStrides(arrLengths);
-
-            return new Tensor<T>(tensor._values, arrLengths, strides, tensor._memoryOffset);
-        }
-
-        /// <summary>
-        /// Reshapes the <paramref name="tensor"/> 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="tensor"><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>(in this TensorSpan<T> tensor, params scoped ReadOnlySpan<nint> lengths)
-        {
-            if (tensor.Lengths.SequenceEqual(lengths))
-                return tensor;
-
-            if (!TensorHelpers.IsContiguousAndDense<T>(tensor) && !tensor.Strides.Contains(0))
-            {
-                ThrowHelper.ThrowArgument_CannotReshapeNonContiguousOrDense();
-            }
-
-            nint[] arrLengths = lengths.ToArray();
-            // Calculate wildcard info.
-            if (lengths.Contains(-1))
-            {
-                if (lengths.Count(-1) > 1)
-                    ThrowHelper.ThrowArgument_OnlyOneWildcard();
-                nint tempTotal = tensor.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 != tensor.FlattenedLength)
-                ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
-
-            nint[] strides;
-
-            // If we contain a 0 stride we can only add dimensions of length 1.
-            if (tensor.Strides.Contains(0))
-            {
-                List<nint> origStrides = new List<nint>(tensor.Strides.ToArray());
-                int lengthOffset = 0;
-                for (int i = 0; i < arrLengths.Length; i++)
-                {
-                    if (lengthOffset < tensor.Rank && arrLengths[i] == tensor.Lengths[lengthOffset])
-                    {
-                        lengthOffset++;
-                    }
-                    else if (arrLengths[i] == 1)
-                    {
-                        if (lengthOffset == tensor.Rank)
-                            origStrides.Add(tensor.Strides[lengthOffset - 1]);
-                        else
-                            origStrides.Insert(i, tensor.Strides[i] * tensor.Lengths[i]);
-                    }
-                    else
-                        ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
-                }
-                strides = origStrides.ToArray();
-            }
-            else
-                strides = TensorSpanHelpers.CalculateStrides(arrLengths);
-
-            TensorSpan<T> output = new TensorSpan<T>(ref tensor._reference, arrLengths, strides, tensor._shape._memoryLength);
-            return output;
-        }
-
-        /// <summary>
-        /// Reshapes the <paramref name="tensor"/> 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="tensor"><see cref="TensorSpan{T}"/> you want to reshape.</param>
-        /// <param name="lengths"><see cref="ReadOnlySpan{T}"/> with the new dimensions.</param>
-        public static ReadOnlyTensorSpan<T> Reshape<T>(in this ReadOnlyTensorSpan<T> tensor, params scoped ReadOnlySpan<nint> lengths)
-        {
-            if (tensor.Lengths.SequenceEqual(lengths))
-                return tensor;
-
-            if (!TensorHelpers.IsContiguousAndDense<T>(tensor) && !tensor.Strides.Contains(0))
-            {
-                ThrowHelper.ThrowArgument_CannotReshapeNonContiguousOrDense();
-            }
-
-            nint[] arrLengths = lengths.ToArray();
-            // Calculate wildcard info.
-            if (lengths.Contains(-1))
-            {
-                if (lengths.Count(-1) > 1)
-                    ThrowHelper.ThrowArgument_OnlyOneWildcard();
-                nint tempTotal = tensor.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 != tensor.FlattenedLength)
-                ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
-
-            nint[] strides;
-
-            // If we contain a 0 stride we can only add dimensions of length 1.
-            if (tensor.Strides.Contains(0))
-            {
-                List<nint> origStrides = new List<nint>(tensor.Strides.ToArray());
-                int lengthOffset = 0;
-                for (int i = 0; i < arrLengths.Length; i++)
-                {
-                    if (lengthOffset < tensor.Rank && arrLengths[i] == tensor.Lengths[lengthOffset])
-                        lengthOffset++;
-                    else if (arrLengths[i] == 1)
-                    {
-                        if (lengthOffset == tensor.Rank)
-                            origStrides.Add(tensor.Strides[lengthOffset - 1]);
-                        else
-                            origStrides.Insert(i, tensor.Strides[i] * tensor.Lengths[i]);
-                    }
-                    else
-                        ThrowHelper.ThrowArgument_InvalidReshapeDimensions();
-                }
-                strides = origStrides.ToArray();
-            }
-            else
-                strides = TensorSpanHelpers.CalculateStrides(arrLengths);
-
-            ReadOnlyTensorSpan<T> output = new ReadOnlyTensorSpan<T>(ref tensor._reference, arrLengths, strides, tensor._shape._memoryLength);
-            return output;
-        }
-        #endregion
-
-        #region Resize
-        /// <summary>
-        /// Creates a new <see cref="Tensor{T}"/>, allocates new memory, and copies the data from <paramref name="tensor"/>. If the final shape is smaller all data after
-        /// that point is ignored.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="lengths"><see cref="ReadOnlySpan{T}"/> of the desired new shape.</param>
-        public static Tensor<T> Resize<T>(Tensor<T> tensor, ReadOnlySpan<nint> lengths)
-        {
-            nint newSize = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = tensor.IsPinned ? GC.AllocateArray<T>((int)newSize) : (new T[newSize]);
-            Tensor<T> output = new Tensor<T>(values, lengths, tensor._memoryOffset, isPinned: false);
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref tensor.AsTensorSpan()._reference, (int)tensor._values.Length);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output.AsTensorSpan()._reference, (int)output.FlattenedLength);
-            if (newSize > tensor._values.Length)
-                TensorSpanHelpers.Memmove(ospan, span, tensor._values.Length);
-            else
-                TensorSpanHelpers.Memmove(ospan, span, newSize);
-
-            return output;
-        }
-
-        /// <summary>
-        /// Copies the data from <paramref name="tensor"/>. If the final shape is smaller all data after that point is ignored.
-        /// If the final shape is bigger it is filled with 0s.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="destination">Destination <see cref="TensorSpan{T}"/> with the desired new shape.</param>
-        public static void ResizeTo<T>(scoped in Tensor<T> tensor, in TensorSpan<T> destination)
-        {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref tensor._values[0], tensor._values.Length);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-            if (destination._shape._memoryLength > tensor._values.Length)
-                TensorSpanHelpers.Memmove(ospan, span, tensor._values.Length);
-            else
-                TensorSpanHelpers.Memmove(ospan, span, destination._shape._memoryLength);
-        }
-
-        /// <summary>
-        /// Copies the data from <paramref name="tensor"/>. If the final shape is smaller all data after that point is ignored.
-        /// If the final shape is bigger it is filled with 0s.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="destination">Destination <see cref="TensorSpan{T}"/> with the desired new shape.</param>
-        public static void ResizeTo<T>(scoped in TensorSpan<T> tensor, in TensorSpan<T> destination)
-        {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref tensor._reference, (int)tensor._shape._memoryLength);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-            if (destination._shape._memoryLength > tensor._shape._memoryLength)
-                TensorSpanHelpers.Memmove(ospan, span, tensor._shape._memoryLength);
-            else
-                TensorSpanHelpers.Memmove(ospan, span, destination._shape._memoryLength);
-        }
-
-        /// <summary>
-        /// Copies the data from <paramref name="tensor"/>. If the final shape is smaller all data after that point is ignored.
-        /// If the final shape is bigger it is filled with 0s.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination">Destination <see cref="TensorSpan{T}"/> with the desired new shape.</param>
-        public static void ResizeTo<T>(scoped in ReadOnlyTensorSpan<T> tensor, in TensorSpan<T> destination)
-        {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref tensor._reference, (int)tensor._shape._memoryLength);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-            if (destination._shape._memoryLength > tensor._shape._memoryLength)
-                TensorSpanHelpers.Memmove(ospan, span, tensor._shape._memoryLength);
-            else
-                TensorSpanHelpers.Memmove(ospan, span, destination._shape._memoryLength);
-        }
-        #endregion
-
-        #region Reverse
-        /// <summary>
-        /// Reverse the order of elements in the <paramref name="tensor"/>. The shape of the tensor is preserved, but the elements are reordered.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
-        public static Tensor<T> Reverse<T>(in ReadOnlyTensorSpan<T> tensor)
-        {
-            Tensor<T> output = Tensor.Create<T>(tensor.Lengths);
-            ReverseDimension(tensor, output, -1);
-
-            return output;
-        }
-
-        /// <summary>
-        /// Reverse the order of elements in the <paramref name="tensor"/> along the given dimension. The shape of the tensor is preserved, but the elements are reordered.
-        /// <paramref name="dimension"/> defaults to -1 when not provided, which reverses the entire tensor.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="dimension">dimension along which to reverse over. -1 will reverse over all of the dimensions of the left tensor.</param>
-        public static Tensor<T> ReverseDimension<T>(in ReadOnlyTensorSpan<T> tensor, int dimension)
-        {
-            Tensor<T> output = Tensor.Create<T>(tensor.Lengths);
-            ReverseDimension(tensor, output, dimension);
-
-            return output;
-        }
-
-        /// <summary>
-        /// Reverse the order of elements in the <paramref name="tensor"/>. The shape of the tensor is preserved, but the elements are reordered.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Reverse<T>(scoped in ReadOnlyTensorSpan<T> tensor, in TensorSpan<T> destination)
-        {
-            return ref ReverseDimension(tensor, destination, -1);
-        }
-
-        /// <summary>
-        /// Reverse the order of elements in the <paramref name="tensor"/> along the given axis. The shape of the tensor is preserved, but the elements are reordered.
-        /// <paramref name="dimension"/> defaults to -1 when not provided, which reverses the entire span.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        /// <param name="dimension">dimension along which to reverse over. -1 will reverse over all of the dimensions of the left tensor.</param>
-        public static ref readonly TensorSpan<T> ReverseDimension<T>(scoped in ReadOnlyTensorSpan<T> tensor, in TensorSpan<T> destination, int dimension)
-        {
-            if (dimension == -1)
-            {
-                nint index = tensor._shape._memoryLength - 1;
-                Span<T> inputSpan = MemoryMarshal.CreateSpan(ref tensor._reference, (int)tensor._shape._memoryLength);
-                Span<T> outputSpan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-                for (int i = 0; i <= tensor._shape._memoryLength / 2; i++)
-                {
-                    outputSpan[i] = inputSpan[(int)index];
-                    outputSpan[(int)index--] = inputSpan[i];
-                }
-            }
-            else
-            {
-                nint copyLength = 1;
-                for (nint i = dimension; i < tensor.Lengths.Length; i++)
-                {
-                    copyLength *= tensor.Lengths[(int)i];
-                }
-                copyLength /= tensor.Lengths[(int)dimension];
-
-                scoped Span<nint> oIndices;
-                nint[]? oIndicesArray;
-                scoped Span<nint> iIndices;
-                nint[]? iIndicesArray;
-                if (tensor.Rank > 6)
-                {
-                    oIndicesArray = ArrayPool<nint>.Shared.Rent(tensor.Rank);
-                    oIndices = oIndicesArray.AsSpan(0, tensor.Rank);
-                    oIndices.Clear();
-
-                    iIndicesArray = ArrayPool<nint>.Shared.Rent(tensor.Rank);
-                    iIndices = iIndicesArray.AsSpan(0, tensor.Rank);
-                    iIndices.Clear();
-                }
-                else
-                {
-                    oIndicesArray = null;
-                    oIndices = stackalloc nint[tensor.Rank];
-                    iIndicesArray = null;
-                    iIndices = stackalloc nint[tensor.Rank];
-                }
-
-                iIndices[(int)dimension] = tensor.Lengths[(int)dimension] - 1;
-                nint copiedValues = 0;
-                ReadOnlyTensorSpan<T> islice = tensor.Slice(tensor.Lengths);
-
-                while (copiedValues < tensor.FlattenedLength)
-                {
-                    TensorSpanHelpers.Memmove(ref Unsafe.Add(ref destination._reference, TensorSpanHelpers.ComputeLinearIndex(oIndices, tensor.Strides, tensor.Lengths)), ref Unsafe.Add(ref islice._reference, TensorSpanHelpers.ComputeLinearIndex(iIndices, islice.Strides, islice.Lengths)), copyLength);
-                    TensorSpanHelpers.AdjustIndexes((int)dimension, 1, oIndices, tensor.Lengths);
-                    TensorSpanHelpers.AdjustIndexesDown((int)dimension, 1, iIndices, tensor.Lengths);
-                    copiedValues += copyLength;
-                }
-
-                if (oIndicesArray != null && iIndicesArray != null)
-                {
-                    ArrayPool<nint>.Shared.Return(oIndicesArray);
-                    ArrayPool<nint>.Shared.Return(iIndicesArray);
-                }
-            }
-
-            return ref destination;
-        }
-        #endregion
-
-        #region SequenceEqual
-        /// <summary>
-        /// Determines whether two sequences are equal by comparing the elements using IEquatable{T}.Equals(T).
-        /// </summary>
-        public static bool SequenceEqual<T>(this scoped in TensorSpan<T> tensor, scoped in ReadOnlyTensorSpan<T> other)
-            where T : IEquatable<T>?
-        {
-            return tensor.FlattenedLength == other.FlattenedLength
-                && tensor._shape._memoryLength == other._shape._memoryLength
-                && tensor.Lengths.SequenceEqual(other.Lengths)
-                && MemoryMarshal.CreateReadOnlySpan(in tensor.GetPinnableReference(), (int)tensor._shape._memoryLength).SequenceEqual(MemoryMarshal.CreateReadOnlySpan(in other.GetPinnableReference(), (int)other._shape._memoryLength));
-        }
-
-        /// <summary>
-        /// Determines whether two sequences are equal by comparing the elements using IEquatable{T}.Equals(T).
-        /// </summary>
-        public static bool SequenceEqual<T>(this scoped in ReadOnlyTensorSpan<T> tensor, scoped in ReadOnlyTensorSpan<T> other)
-            where T : IEquatable<T>?
-        {
-            return tensor.FlattenedLength == other.FlattenedLength
-                && tensor._shape._memoryLength == other._shape._memoryLength
-                && tensor.Lengths.SequenceEqual(other.Lengths)
-                && MemoryMarshal.CreateReadOnlySpan(in tensor.GetPinnableReference(), (int)tensor._shape._memoryLength).SequenceEqual(MemoryMarshal.CreateReadOnlySpan(in other.GetPinnableReference(), (int)other._shape._memoryLength));
-        }
-        #endregion
-
-        #region SetSlice
-        /// <summary>
-        /// Sets a slice of the given <paramref name="tensor"/> with the provided <paramref name="values"/> for the given <paramref name="ranges"/>
-        /// </summary>
-        /// <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, in ReadOnlyTensorSpan<T> values, params ReadOnlySpan<NRange> ranges)
-        {
-            SetSlice((TensorSpan<T>)tensor, values, ranges);
-
-            return tensor;
-        }
-
-        /// <summary>
-        /// Sets a slice of the given <paramref name="tensor"/> with the provided <paramref name="values"/> for the given <paramref name="ranges"/>
-        /// </summary>
-        /// <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 ref readonly TensorSpan<T> SetSlice<T>(this in TensorSpan<T> tensor, scoped in ReadOnlyTensorSpan<T> values, params scoped ReadOnlySpan<NRange> ranges)
-        {
-            TensorSpan<T> srcSpan;
-            if (ranges == ReadOnlySpan<NRange>.Empty)
-            {
-                if (!TensorHelpers.IsBroadcastableTo(values.Lengths, tensor.Lengths))
-                    ThrowHelper.ThrowArgument_SetSliceNoRange(nameof(values));
-                srcSpan = tensor;
-            }
-            else
-                srcSpan = tensor.Slice(ranges);
-
-            if (!TensorHelpers.IsContiguousAndDense<T>(srcSpan))
-                ThrowHelper.ThrowArgument_SetSliceInvalidShapes(nameof(values));
-
-            if (!TensorHelpers.IsBroadcastableTo(values.Lengths, srcSpan.Lengths))
-                ThrowHelper.ThrowArgument_SetSliceInvalidShapes(nameof(values));
-
-            values.CopyTo(srcSpan);
-
-            return ref tensor;
-        }
-        #endregion
-
-        #region Split
-        /// <summary>
-        /// Split a <see cref="Tensor{T}"/> into <paramref name="splitCount"/> along the given <paramref name="dimension"/>. If the tensor cannot be split
-        /// evenly on the given <paramref name="dimension"/> an exception is thrown.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="splitCount">How many times to split the <paramref name="tensor"/></param>
-        /// <param name="dimension">The axis to split on.</param>
-        public static Tensor<T>[] Split<T>(scoped in ReadOnlyTensorSpan<T> tensor, int splitCount, nint dimension)
-        {
-            if (tensor.Lengths[(int)dimension] % splitCount != 0)
-                ThrowHelper.ThrowArgument_SplitNotSplitEvenly();
-
-            Tensor<T>[] outputs = new Tensor<T>[splitCount];
-
-            nint totalToCopy = tensor.FlattenedLength / splitCount;
-            nint copyLength = 1;
-            for (nint i = dimension; i < tensor.Lengths.Length; i++)
-            {
-                copyLength *= tensor.Lengths[(int)i];
-            }
-            copyLength /= splitCount;
-            nint[] newShape = tensor.Lengths.ToArray();
-            newShape[(int)dimension] = newShape[(int)dimension] / splitCount;
-
-            scoped Span<nint> oIndices;
-            nint[]? oIndicesArray;
-            scoped Span<nint> iIndices;
-            nint[]? iIndicesArray;
-            if (tensor.Rank > 6)
-            {
-                oIndicesArray = ArrayPool<nint>.Shared.Rent(tensor.Rank);
-                oIndices = oIndicesArray.AsSpan(0, tensor.Rank);
-                oIndices.Clear();
-
-                iIndicesArray = ArrayPool<nint>.Shared.Rent(tensor.Rank);
-                iIndices = iIndicesArray.AsSpan(0, tensor.Rank);
-                iIndices.Clear();
-            }
-            else
-            {
-                oIndicesArray = null;
-                oIndices = stackalloc nint[tensor.Rank];
-                iIndicesArray = null;
-                iIndices = stackalloc nint[tensor.Rank];
-            }
-
-            for (int i = 0; i < outputs.Length; i++)
-            {
-                T[] values = new T[(int)totalToCopy];
-                outputs[i] = new Tensor<T>(values, newShape, memoryOffset: 0);
-                oIndices.Clear();
-                iIndices.Clear();
-
-                iIndices[(int)dimension] = i;
-                ReadOnlyTensorSpan<T> islice = tensor.Slice(tensor.Lengths);
-                TensorSpan<T> oslice = outputs[i].AsTensorSpan().Slice(outputs[i]._lengths);
-
-                nint copiedValues = 0;
-                while (copiedValues < totalToCopy)
-                {
-                    TensorSpanHelpers.Memmove(ref Unsafe.Add(ref oslice._reference, TensorSpanHelpers.ComputeLinearIndex(oIndices, outputs[0].Strides, outputs[0].Lengths)), ref Unsafe.Add(ref islice._reference, TensorSpanHelpers.ComputeLinearIndex(iIndices, islice.Strides, islice.Lengths)), copyLength);
-                    TensorSpanHelpers.AdjustIndexes((int)dimension, 1, oIndices, outputs[i]._lengths);
-                    TensorSpanHelpers.AdjustIndexes((int)dimension - 1, 1, iIndices, tensor.Lengths);
-                    copiedValues += copyLength;
-                }
-            }
-
-            if (oIndicesArray != null && iIndicesArray != null)
-            {
-                ArrayPool<nint>.Shared.Return(oIndicesArray);
-                ArrayPool<nint>.Shared.Return(iIndicesArray);
-            }
-
-            return outputs;
-        }
-        #endregion
-
-        #region Squeeze
-        /// <summary>
-        /// Removes all dimensions of length one from the <paramref name="tensor"/>.
-        /// </summary>
-        /// <param name="tensor">The <see cref="Tensor{T}"/> to remove all dimensions of length 1.</param>
-        public static Tensor<T> Squeeze<T>(this Tensor<T> tensor)
-        {
-            return SqueezeDimension(tensor, -1);
-        }
-
-        /// <summary>
-        /// Removes axis of length one from the <paramref name="tensor"/> for the given <paramref name="dimension"/>.
-        /// If the dimension is not of length one it will throw an exception.
-        /// </summary>
-        /// <param name="tensor">The <see cref="Tensor{T}"/> to remove dimension of length 1.</param>
-        /// <param name="dimension">The dimension to remove.</param>
-        public static Tensor<T> SqueezeDimension<T>(this Tensor<T> tensor, int dimension)
-        {
-            if (dimension >= tensor.Rank)
-                ThrowHelper.ThrowArgument_AxisLargerThanRank();
-
-            nint[] lengths;
-            nint[] strides;
-
-            List<nint> tempLengths = new List<nint>();
-            if (dimension == -1)
-            {
-                for (int i = 0; i < tensor.Lengths.Length; i++)
-                {
-                    if (tensor.Lengths[i] != 1)
-                    {
-                        tempLengths.Add(tensor.Lengths[i]);
-                    }
-                }
-                lengths = tempLengths.ToArray();
-                strides = TensorSpanHelpers.CalculateStrides(lengths);
-            }
-            else
-            {
-                if (tensor.Lengths[dimension] != 1)
-                {
-                    ThrowHelper.ThrowArgument_InvalidSqueezeAxis();
-                }
-                for (int i = 0; i < tensor.Lengths.Length; i++)
-                {
-                    if (i != dimension)
-                    {
-                        tempLengths.Add(tensor.Lengths[i]);
-                    }
-                }
-                lengths = tempLengths.ToArray();
-                strides = TensorSpanHelpers.CalculateStrides(lengths);
-            }
-
-            return new Tensor<T>(tensor._values, lengths, strides, tensor._memoryOffset);
-        }
-
-        /// <summary>
-        /// Removes all dimensions of length one from the <paramref name="tensor"/>.
-        /// </summary>
-        /// <param name="tensor">The <see cref="TensorSpan{T}"/> to remove all dimensions of length 1.</param>
-        public static TensorSpan<T> Squeeze<T>(in this TensorSpan<T> tensor)
-        {
-            return SqueezeDimension(tensor, -1);
-        }
-
-        /// <summary>
-        /// Removes axis of length one from the <paramref name="tensor"/> for the given <paramref name="dimension"/>.
-        /// If the dimension is not of length one it will throw an exception.
-        /// </summary>
-        /// <param name="tensor">The <see cref="TensorSpan{T}"/> to remove dimension of length 1.</param>
-        /// <param name="dimension">The dimension to remove.</param>
-        public static TensorSpan<T> SqueezeDimension<T>(in this TensorSpan<T> tensor, int dimension)
-        {
-            if (dimension >= tensor.Rank)
-                ThrowHelper.ThrowArgument_AxisLargerThanRank();
-
-            nint[] lengths;
-            nint[] strides;
-
-            List<nint> tempLengths = new List<nint>();
-            if (dimension == -1)
-            {
-                for (int i = 0; i < tensor.Lengths.Length; i++)
-                {
-                    if (tensor.Lengths[i] != 1)
-                    {
-                        tempLengths.Add(tensor.Lengths[i]);
-                    }
-                }
-                lengths = tempLengths.ToArray();
-                strides = TensorSpanHelpers.CalculateStrides(lengths);
-            }
-            else
-            {
-                if (tensor.Lengths[dimension] != 1)
-                {
-                    ThrowHelper.ThrowArgument_InvalidSqueezeAxis();
-                }
-                for (int i = 0; i < tensor.Lengths.Length; i++)
-                {
-                    if (i != dimension)
-                    {
-                        tempLengths.Add(tensor.Lengths[i]);
-                    }
-                }
-                lengths = tempLengths.ToArray();
-                strides = TensorSpanHelpers.CalculateStrides(lengths);
-            }
-
-            return new TensorSpan<T>(ref tensor._reference, lengths, strides, tensor._shape._memoryLength);
-        }
-
-        /// <summary>
-        /// Removes all dimensions of length one from the <paramref name="tensor"/>.
-        /// </summary>
-        /// <param name="tensor">The <see cref="ReadOnlyTensorSpan{T}"/> to remove all dimensions of length 1.</param>
-        public static ReadOnlyTensorSpan<T> Squeeze<T>(in this ReadOnlyTensorSpan<T> tensor)
-        {
-            return SqueezeDimension(tensor, -1);
-        }
-
-        /// <summary>
-        /// Removes axis of length one from the <paramref name="tensor"/> for the given <paramref name="dimension"/>.
-        /// If the dimension is not of length one it will throw an exception.
-        /// </summary>
-        /// <param name="tensor">The <see cref="ReadOnlyTensorSpan{T}"/> to remove dimension of length 1.</param>
-        /// <param name="dimension">The dimension to remove.</param>
-        public static ReadOnlyTensorSpan<T> SqueezeDimension<T>(in this ReadOnlyTensorSpan<T> tensor, int dimension)
-        {
-            if (dimension >= tensor.Rank)
-                ThrowHelper.ThrowArgument_AxisLargerThanRank();
-
-            nint[] lengths;
-            nint[] strides;
-
-            List<nint> tempLengths = new List<nint>();
-            if (dimension == -1)
-            {
-                for (int i = 0; i < tensor.Lengths.Length; i++)
-                {
-                    if (tensor.Lengths[i] != 1)
-                    {
-                        tempLengths.Add(tensor.Lengths[i]);
-                    }
-                }
-                lengths = tempLengths.ToArray();
-                strides = TensorSpanHelpers.CalculateStrides(lengths);
-            }
-            else
-            {
-                if (tensor.Lengths[dimension] != 1)
-                {
-                    ThrowHelper.ThrowArgument_InvalidSqueezeAxis();
-                }
-                for (int i = 0; i < tensor.Lengths.Length; i++)
-                {
-                    if (i != dimension)
-                    {
-                        tempLengths.Add(tensor.Lengths[i]);
-                    }
-                }
-                lengths = tempLengths.ToArray();
-                strides = TensorSpanHelpers.CalculateStrides(lengths);
-            }
-
-            return new ReadOnlyTensorSpan<T>(ref tensor._reference, lengths, strides, tensor._shape._memoryLength);
-        }
-        #endregion
-
-        #region Stack
-        /// <summary>
-        /// Join multiple <see cref="Tensor{T}"/> along a new dimension that is added at position 0. All tensors must have the same shape.
-        /// </summary>
-        /// <param name="tensors">Input <see cref="Tensor{T}"/>.</param>
-        public static Tensor<T> Stack<T>(params ReadOnlySpan<Tensor<T>> tensors)
-        {
-            return StackAlongDimension(0, tensors);
-        }
-
-        /// <summary>
-        /// Join multiple <see cref="Tensor{T}"/> along a new dimension. The axis parameter specifies the index of the new dimension. All tensors must have the same shape.
-        /// </summary>
-        /// <param name="tensors">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="dimension">Index of where the new dimension will be.</param>
-        public static Tensor<T> StackAlongDimension<T>(int dimension, params ReadOnlySpan<Tensor<T>> tensors)
-        {
-            if (tensors.Length < 2)
-                ThrowHelper.ThrowArgument_StackTooFewTensors();
-
-            for (int i = 1; i < tensors.Length; i++)
-            {
-                if (!TensorHelpers.AreLengthsTheSame<T>(tensors[0], tensors[i]))
-                    ThrowHelper.ThrowArgument_StackShapesNotSame();
-            }
-
-            if (dimension < 0)
-                dimension = tensors[0].Rank - dimension;
-
-            Tensor<T>[] outputs = new Tensor<T>[tensors.Length];
-            for (int i = 0; i < tensors.Length; i++)
-            {
-                outputs[i] = Tensor.Unsqueeze(tensors[i], dimension);
-            }
-            return Tensor.ConcatenateOnDimension<T>(dimension, outputs);
-        }
-
-        /// <summary>
-        /// Join multiple <see cref="Tensor{T}"/> along a new dimension that is added at position 0. All tensors must have the same shape.
-        /// </summary>
-        /// <param name="tensors">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Stack<T>(scoped in ReadOnlySpan<Tensor<T>> tensors, in TensorSpan<T> destination)
-        {
-            return ref StackAlongDimension(tensors, destination, 0);
-        }
-
-        /// <summary>
-        /// Join multiple <see cref="Tensor{T}"/> along a new dimension. The axis parameter specifies the index of the new dimension. All tensors must have the same shape.
-        /// </summary>
-        /// <param name="tensors">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="destination"></param>
-        /// <param name="dimension">Index of where the new dimension will be.</param>
-        public static ref readonly TensorSpan<T> StackAlongDimension<T>(scoped ReadOnlySpan<Tensor<T>> tensors, in TensorSpan<T> destination, int dimension)
-        {
-            if (tensors.Length < 2)
-                ThrowHelper.ThrowArgument_StackTooFewTensors();
-
-            for (int i = 1; i < tensors.Length; i++)
-            {
-                if (!TensorHelpers.AreLengthsTheSame<T>(tensors[0], tensors[i]))
-                    ThrowHelper.ThrowArgument_StackShapesNotSame();
-            }
-
-            if (dimension < 0)
-                dimension = tensors[0].Rank - dimension;
-
-            Tensor<T>[] outputs = new Tensor<T>[tensors.Length];
-            for (int i = 0; i < tensors.Length; i++)
-            {
-                outputs[i] = Tensor.Unsqueeze(tensors[i], dimension);
-            }
-            return ref Tensor.ConcatenateOnDimension<T>(dimension, outputs, destination);
-        }
-        #endregion
-
-        #region ToString
-        /// <summary>
-        /// Creates a <see cref="string"/> representation of the <see cref="TensorSpan{T}"/>."/>
-        /// </summary>
-        /// <param name="tensor">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="tensor"/></returns>
-        public static string ToString<T>(this in TensorSpan<T> tensor, params ReadOnlySpan<nint> maximumLengths) =>
-            ((ReadOnlyTensorSpan<T>)tensor).ToString(maximumLengths);
-
-        /// <summary>
-        /// Creates a <see cref="string"/> representation of the <see cref="ReadOnlyTensorSpan{T}"/>."/>
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="tensor">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 in ReadOnlyTensorSpan<T> tensor, params ReadOnlySpan<nint> maximumLengths)
-        {
-            StringBuilder sb = new();
-            ToString(in tensor, sb, maximumLengths);
-            return sb.ToString();
-        }
-
-        internal static void ToString<T>(this in ReadOnlyTensorSpan<T> tensor, StringBuilder sb, params ReadOnlySpan<nint> maximumLengths)
-        {
-            if (maximumLengths.Length != tensor.Rank)
-                ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(tensor));
-
-            scoped Span<nint> curIndexes;
-            nint[]? curIndexesArray;
-            if (tensor.Rank > 6)
-            {
-                curIndexesArray = ArrayPool<nint>.Shared.Rent(tensor.Rank);
-                curIndexes = curIndexesArray.AsSpan(0, tensor.Rank);
-                curIndexes.Clear();
-            }
-            else
-            {
-                curIndexesArray = null;
-                curIndexes = stackalloc nint[tensor.Rank];
-            }
-
-            nint copiedValues = 0;
-
-            T[] values = new T[tensor.Lengths[tensor.Rank - 1]];
-            while (copiedValues < tensor.FlattenedLength)
-            {
-                var sp = new ReadOnlyTensorSpan<T>(ref Unsafe.Add(ref tensor._reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, tensor.Strides, tensor.Lengths)), [tensor.Lengths[tensor.Rank - 1]], [1], tensor.Lengths[tensor.Rank - 1]);
-                sb.Append('{');
-                sp.FlattenTo(values);
-                sb.Append(string.Join(",", values));
-                sb.AppendLine("}");
-
-                TensorSpanHelpers.AdjustIndexes(tensor.Rank - 2, 1, curIndexes, tensor.Lengths);
-                copiedValues += tensor.Lengths[tensor.Rank - 1];
-            }
-
-            if (curIndexesArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexesArray);
-        }
-
-        /// <summary>
-        /// Creates a <see cref="string"/> representation of the <see cref="Tensor{T}"/>."/>
-        /// </summary>
-        /// <param name="tensor">The <see cref="Span{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="tensor"/></returns>
-        public static string ToString<T>(this Tensor<T> tensor, params ReadOnlySpan<nint> maximumLengths) => ((ReadOnlyTensorSpan<T>)tensor).ToString(maximumLengths);
-
-        #endregion
-
-        #region Transpose
-        /// <summary>
-        /// Swaps the last two dimensions of the <paramref name="tensor"/> tensor.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
-        public static Tensor<T> Transpose<T>(Tensor<T> tensor)
-        {
-            if (tensor.Lengths.Length < 2)
-                ThrowHelper.ThrowArgument_TransposeTooFewDimensions();
-
-            Span<int> dimension = tensor.Rank <= TensorShape.MaxInlineRank ? stackalloc int[tensor.Rank] : new int[tensor.Rank];
-            TensorSpanHelpers.FillRange(dimension);
-
-            int temp = dimension[tensor.Rank - 1];
-            dimension[tensor.Rank - 1] = dimension[tensor.Rank - 2];
-            dimension[tensor.Rank - 2] = temp;
-
-            return PermuteDimensions(tensor, dimension);
-        }
-        #endregion
-
-        #region TryBroadcastTo
-        /// <summary>
-        /// Broadcast the data from <paramref name="tensor"/> to the smallest broadcastable shape compatible with <paramref name="destination"/> and stores it in <paramref name="destination"/>
-        /// If the shapes are not compatible, false is returned.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="Tensor{T}"/>.</param>
-        /// <param name="destination">Destination <see cref="TensorSpan{T}"/>.</param>
-        public static bool TryBroadcastTo<T>(this Tensor<T> tensor, in TensorSpan<T> destination)
-        {
-            return TryBroadcastTo((ReadOnlyTensorSpan<T>)tensor, destination);
-        }
-
-        /// <summary>
-        /// Broadcast the data from <paramref name="tensor"/> to the smallest broadcastable shape compatible with <paramref name="destination"/> and stores it in <paramref name="destination"/>
-        /// If the shapes are not compatible, false is returned.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="TensorSpan{T}"/>.</param>
-        /// <param name="destination">Destination <see cref="TensorSpan{T}"/>.</param>
-        public static bool TryBroadcastTo<T>(in this TensorSpan<T> tensor, in TensorSpan<T> destination)
-        {
-            return TryBroadcastTo((ReadOnlyTensorSpan<T>)tensor, destination);
-        }
-
-        /// <summary>
-        /// Broadcast the data from <paramref name="tensor"/> to the smallest broadcastable shape compatible with <paramref name="destination"/> and stores it in <paramref name="destination"/>
-        /// If the shapes are not compatible, false is returned.
-        /// </summary>
-        /// <param name="tensor">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination">Destination <see cref="TensorSpan{T}"/>.</param>
-        public static bool TryBroadcastTo<T>(in this ReadOnlyTensorSpan<T> tensor, in TensorSpan<T> destination)
-        {
-            if (!TensorHelpers.IsBroadcastableTo(tensor.Lengths, destination.Lengths))
-                return false;
-
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(tensor.Lengths, destination.Lengths);
-            if (!TensorHelpers.AreLengthsTheSame(destination.Lengths, newSize))
-                return false;
-
-            LazyBroadcast(tensor, newSize).CopyTo(destination);
-            return true;
-        }
-        #endregion
-
-        #region Unsqueeze
-        /// <summary>
-        /// Insert a new dimension of length 1 that will appear at the dimension position.
-        /// </summary>
-        /// <param name="tensor">The <see cref="Tensor{T}"/> to add a dimension of length 1.</param>
-        /// <param name="dimension">The index of the dimension to add.</param>
-        public static Tensor<T> Unsqueeze<T>(this Tensor<T> tensor, int dimension)
-        {
-            if (dimension > tensor.Lengths.Length)
-                ThrowHelper.ThrowArgument_AxisLargerThanRank();
-            if (dimension < 0)
-                dimension = tensor.Rank - dimension;
-
-            Span<nint> lengths = tensor._lengths.Length + 1 <= TensorShape.MaxInlineRank ?
-                stackalloc nint[tensor._lengths.Length + 1] :
-                new nint[tensor._lengths.Length + 1];
-            tensor._lengths.AsSpan(0, dimension).CopyTo(lengths);
-            tensor._lengths.AsSpan(dimension).CopyTo(lengths.Slice(dimension + 1));
-            lengths[dimension] = 1;
-
-            Span<nint> strides = tensor.Strides.Length + 1 <= TensorShape.MaxInlineRank ?
-                stackalloc nint[tensor.Strides.Length + 1] :
-                new nint[tensor.Strides.Length + 1];
-            if (dimension == tensor.Rank)
-            {
-                tensor.Strides.CopyTo(strides);
-                strides[dimension] = tensor.Strides[dimension - 1];
-            }
-            else
-            {
-                tensor.Strides.Slice(0, dimension).CopyTo(strides);
-                tensor.Strides.Slice(dimension).CopyTo(strides.Slice(dimension + 1));
-                strides[dimension] = tensor.Strides[dimension] * tensor.Lengths[dimension];
-            }
-
-            return new Tensor<T>(tensor._values, lengths, strides, tensor._memoryOffset);
-        }
-
-        /// <summary>
-        /// Insert a new dimension of length 1 that will appear at the dimension position.
-        /// </summary>
-        /// <param name="tensor">The <see cref="TensorSpan{T}"/> to add a dimension of length 1.</param>
-        /// <param name="dimension">The index of the dimension to add.</param>
-        public static TensorSpan<T> Unsqueeze<T>(in this TensorSpan<T> tensor, int dimension)
-        {
-            if (dimension > tensor.Lengths.Length)
-                ThrowHelper.ThrowArgument_AxisLargerThanRank();
-            if (dimension < 0)
-                dimension = tensor.Rank - dimension;
-
-            Span<nint> lengths = tensor.Lengths.Length + 1 <= TensorShape.MaxInlineRank ?
-                stackalloc nint[tensor.Lengths.Length + 1] :
-                new nint[tensor.Lengths.Length + 1];
-            tensor.Lengths.Slice(0, dimension).CopyTo(lengths);
-            tensor.Lengths.Slice(dimension).CopyTo(lengths.Slice(dimension + 1));
-            lengths[dimension] = 1;
-
-            Span<nint> strides = tensor.Strides.Length + 1 <= TensorShape.MaxInlineRank ?
-                stackalloc nint[tensor.Strides.Length + 1] :
-                new nint[tensor.Strides.Length + 1];
-            if (dimension == tensor.Rank)
-            {
-                tensor.Strides.CopyTo(strides);
-                strides[dimension] = tensor.Strides[dimension - 1];
-            }
-            else
-            {
-                tensor.Strides.Slice(0, dimension).CopyTo(strides);
-                tensor.Strides.Slice(dimension).CopyTo(strides.Slice(dimension + 1));
-                strides[dimension] = tensor.Strides[dimension] * tensor.Lengths[dimension];
-            }
-
-            return new TensorSpan<T>(ref tensor._reference, lengths, strides, tensor._shape._memoryLength);
-        }
-
-        /// <summary>
-        /// Insert a new dimension of length 1 that will appear at the dimension position.
-        /// </summary>
-        /// <param name="tensor">The <see cref="ReadOnlyTensorSpan{T}"/> to add a dimension of length 1.</param>
-        /// <param name="dimension">The index of the dimension to add.</param>
-        public static ReadOnlyTensorSpan<T> Unsqueeze<T>(in this ReadOnlyTensorSpan<T> tensor, int dimension)
-        {
-            if (dimension > tensor.Lengths.Length)
-                ThrowHelper.ThrowArgument_AxisLargerThanRank();
-            if (dimension < 0)
-                dimension = tensor.Rank - dimension;
-
-            Span<nint> lengths = tensor.Lengths.Length + 1 <= TensorShape.MaxInlineRank ?
-                stackalloc nint[tensor.Lengths.Length + 1] :
-                new nint[tensor.Lengths.Length + 1];
-            tensor.Lengths.Slice(0, dimension).CopyTo(lengths);
-            tensor.Lengths.Slice(dimension).CopyTo(lengths.Slice(dimension + 1));
-            lengths[dimension] = 1;
-
-            Span<nint> strides = tensor.Strides.Length + 1 <= TensorShape.MaxInlineRank ?
-                stackalloc nint[tensor.Strides.Length + 1] :
-                new nint[tensor.Strides.Length + 1];
-            if (dimension == tensor.Rank)
-            {
-                tensor.Strides.CopyTo(strides);
-                strides[dimension] = tensor.Strides[dimension - 1];
-            }
-            else
-            {
-                tensor.Strides.Slice(0, dimension).CopyTo(strides);
-                tensor.Strides.Slice(dimension).CopyTo(strides.Slice(dimension + 1));
-                strides[dimension] = tensor.Strides[dimension] * tensor.Lengths[dimension];
-            }
-
-            return new ReadOnlyTensorSpan<T>(ref tensor._reference, lengths, strides, tensor._shape._memoryLength);
-        }
-        #endregion
-
-        #region TensorPrimitives
-        #region Abs
-        /// <summary>
-        /// 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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the abs of.</param>
-        public static Tensor<T> Abs<T>(in ReadOnlyTensorSpan<T> x)
-            where T : INumberBase<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Abs(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the absolute value of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="TensorSpan{T}"/> to take the abs of.</param>
-        /// <param name="destination">The <see cref="TensorSpan{T}"/> destination.</param>
-        public static ref readonly TensorSpan<T> Abs<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : INumberBase<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Abs);
-        }
-        #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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> Acos<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Acos(x, output);
-            return output;
-        }
-
-        /// <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="x">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Acos<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Acos);
-        }
-        #endregion
-
-        #region Acosh
-        /// <summary>
-        /// Takes the inverse hyperbolic cosine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> Acosh<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IHyperbolicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Acosh(x, output);
-            return output;
-        }
-
-        /// <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="x">The <see cref="TensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Acosh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IHyperbolicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Acosh);
-        }
-        #endregion
-
-        #region AcosPi
-        /// <summary>
-        /// 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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> AcosPi<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            AcosPi(x, output);
-            return output;
-        }
-
-        /// <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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> AcosPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.AcosPi);
-        }
-        #endregion
-
-        #region Add
-        /// <summary>
-        /// Adds each element of <paramref name="x"/> to each element of <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        /// <param name="y">The second <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        public static Tensor<T> Add<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Add(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Adds <paramref name="y"/> to each element of <paramref name="x"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        /// <param name="y">The <typeparamref name="T"/> to add to each element of <paramref name="x"/>.</param>
-        public static Tensor<T> Add<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Add(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Adds each element of <paramref name="x"/> to each element of <paramref name="y"/> and returns a new <see cref="ReadOnlyTensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        /// <param name="y">The second <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Add<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Add);
-        }
-
-        /// <summary>
-        /// Adds <paramref name="y"/> to each element of <paramref name="x"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to add.</param>
-        /// <param name="y">The <typeparamref name="T"/> to add to each element of <paramref name="x"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Add<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.Add);
-        }
-        #endregion
-
-        #region Asin
-        /// <summary>
-        /// Takes the inverse sin of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> Asin<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Asin(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the inverse sin of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Asin<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Asin);
-        }
-        #endregion
-
-        #region Asinh
-        /// <summary>
-        /// Takes the inverse hyperbolic sine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> Asinh<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IHyperbolicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Asinh(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the inverse hyperbolic sine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Asinh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IHyperbolicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Asinh);
-        }
-        #endregion
-
-        #region AsinPi
-        /// <summary>
-        /// Takes the inverse hyperbolic sine divided by pi of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> AsinPi<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            AsinPi(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the inverse hyperbolic sine divided by pi of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> AsinPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.AsinPi);
-        }
-        #endregion
-
-        #region Atan
-        /// <summary>
-        /// Takes the arc tangent of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        public static Tensor<T> Atan<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Atan(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the arc tangent of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Atan<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Atan);
-        }
-        #endregion
-
-        #region Atan2
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Atan2<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IFloatingPointIeee754<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Atan2(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Atan2<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IFloatingPointIeee754<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Atan2);
-        }
-
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Atan2<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IFloatingPointIeee754<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-
-            Atan2(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Atan2<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IFloatingPointIeee754<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.Atan2);
-        }
-
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Atan2<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IFloatingPointIeee754<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(y.Lengths);
-
-            Atan2(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Atan2<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IFloatingPointIeee754<T>
-        {
-            return ref TensorPrimitivesHelperTInSpanInSpanOut(x, y, destination, TensorPrimitives.Atan2);
-        }
-        #endregion
-
-        #region Atan2Pi
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Atan2Pi<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IFloatingPointIeee754<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Atan2Pi(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Atan2Pi<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IFloatingPointIeee754<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Atan2Pi);
-        }
-
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Atan2Pi<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IFloatingPointIeee754<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-
-            Atan2Pi(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Atan2Pi<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IFloatingPointIeee754<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.Atan2Pi);
-        }
-
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Atan2Pi<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IFloatingPointIeee754<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(y.Lengths);
-
-            Atan2Pi(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the arc tangent of the two input <see cref="ReadOnlyTensorSpan{T}"/>, divides each element by pi, and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Atan2Pi<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IFloatingPointIeee754<T>
-        {
-            return ref TensorPrimitivesHelperTInSpanInSpanOut(x, y, destination, TensorPrimitives.Atan2Pi);
-
-        }
-        #endregion
-
-        #region Atanh
-        /// <summary>
-        /// Takes the inverse hyperbolic tangent of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Atanh<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IHyperbolicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Atanh(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the inverse hyperbolic tangent of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Atanh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IHyperbolicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Atanh);
-        }
-        #endregion
-
-        #region AtanPi
-        /// <summary>
-        /// Takes the inverse hyperbolic tangent divided by pi of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The input<see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> AtanPi<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            AtanPi(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the inverse hyperbolic tangent divided by pi of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The input<see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> AtanPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.AtanPi);
-        }
-        #endregion
-
-        #region Average
-        /// <summary>
-        /// Returns the average of the elements in the <paramref name="x"/> tensor.
-        /// </summary>
-        /// <param name="x">The <see cref="TensorSpan{T}"/> to take the mean of.</param>
-        /// <returns><typeparamref name="T"/> representing the mean.</returns>
-        public static T Average<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumberBase<T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.Average);
-        }
-        #endregion
-
-        #region BitwiseAnd
-        /// <summary>
-        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> BitwiseAnd<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            BitwiseAnd(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> BitwiseAnd<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.BitwiseAnd);
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        public static Tensor<T> BitwiseAnd<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-
-            BitwiseAnd(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise and of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> BitwiseAnd<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.BitwiseAnd);
-        }
-        #endregion
-
-        #region BitwiseOr
-        /// <summary>
-        /// Computes the element-wise bitwise of of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> BitwiseOr<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            BitwiseOr(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise of of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> BitwiseOr<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.BitwiseOr);
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise or of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        public static Tensor<T> BitwiseOr<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-
-            BitwiseOr(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Computes the element-wise bitwise or of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> BitwiseOr<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.BitwiseOr);
-        }
-        #endregion
-
-        #region CubeRoot
-        /// <summary>
-        /// Computes the element-wise cube root of the input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Cbrt<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IRootFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Cbrt(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Computes the element-wise cube root of the input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Cbrt<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IRootFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Cbrt);
-        }
-        #endregion
-
-        #region Ceiling
-        /// <summary>
-        /// Computes the element-wise ceiling of the input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Ceiling<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IFloatingPoint<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Ceiling(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Computes the element-wise ceiling of the input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Ceiling<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IFloatingPoint<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Ceiling);
-        }
-        #endregion
-
-        #region ConvertChecked
-        /// <summary>
-        /// Copies <paramref name="source"/> to a new <see cref="ReadOnlyTensorSpan{TTO}"/> converting each <typeparamref name="TFrom"/>
-        /// value to a <typeparamref name="TTo"/> value.
-        /// </summary>
-        /// <param name="source">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<TTo> ConvertChecked<TFrom, TTo>(in ReadOnlyTensorSpan<TFrom> source)
-            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
-            where TTo : INumberBase<TTo>
-        {
-            Tensor<TTo> output = Tensor.Create<TTo>(source.Lengths);
-
-            ConvertChecked<TFrom, TTo>(source, output);
-            return output;
-        }
-
-        /// <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{TFrom}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<TTo> ConvertChecked<TFrom, TTo>(scoped in ReadOnlyTensorSpan<TFrom> source, in TensorSpan<TTo> destination)
-            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
-            where TTo : INumberBase<TTo>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(source, destination, TensorPrimitives.ConvertChecked);
-        }
-        #endregion
-
-        #region ConvertSaturating
-        /// <summary>
-        /// Copies <paramref name="source"/> to a new <see cref="ReadOnlyTensorSpan{TTO}"/> converting each <typeparamref name="TFrom"/>
-        /// value to a <typeparamref name="TTo"/> value.
-        /// </summary>
-        /// <param name="source">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<TTo> ConvertSaturating<TFrom, TTo>(in ReadOnlyTensorSpan<TFrom> source)
-            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
-            where TTo : INumberBase<TTo>
-        {
-            Tensor<TTo> output = Tensor.Create<TTo>(source.Lengths);
-
-            ConvertSaturating<TFrom, TTo>(source, output);
-            return output;
-        }
-
-        /// <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{TFrom}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<TTo> ConvertSaturating<TFrom, TTo>(scoped in ReadOnlyTensorSpan<TFrom> source, in TensorSpan<TTo> destination)
-            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
-            where TTo : INumberBase<TTo>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(source, destination, TensorPrimitives.ConvertSaturating);
-        }
-        #endregion
-
-        #region ConvertTruncating
-        /// <summary>
-        /// Copies <paramref name="source"/> to a new <see cref="ReadOnlyTensorSpan{TTO}"/> converting each <typeparamref name="TFrom"/>
-        /// value to a <typeparamref name="TTo"/> value.
-        /// </summary>
-        /// <param name="source">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<TTo> ConvertTruncating<TFrom, TTo>(in ReadOnlyTensorSpan<TFrom> source)
-            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
-            where TTo : INumberBase<TTo>
-        {
-            Tensor<TTo> output = Tensor.Create<TTo>(source.Lengths);
-
-            ConvertTruncating<TFrom, TTo>(source, output);
-            return output;
-        }
-
-        /// <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{TFrom}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<TTo> ConvertTruncating<TFrom, TTo>(scoped in ReadOnlyTensorSpan<TFrom> source, in TensorSpan<TTo> destination)
-            where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
-            where TTo : INumberBase<TTo>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(source, destination, 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="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="sign">The number with the associated sign.</param>
-        public static Tensor<T> CopySign<T>(in ReadOnlyTensorSpan<T> x, T sign)
-            where T : INumber<T>
-        {
-            Tensor<T> output = Create<T>(x.Lengths);
-
-            CopySign(x, sign, output);
-            return output;
-        }
-
-        /// <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="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="sign">The <see cref="ReadOnlyTensorSpan{T}"/> with the associated signs.</param>
-        public static Tensor<T> CopySign<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> sign)
-            where T : INumber<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(sign.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, sign.Lengths));
-            }
-
-            CopySign(x, sign, output);
-            return output;
-        }
-
-        /// <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="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="sign">The number with the associated sign.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> CopySign<T>(scoped in ReadOnlyTensorSpan<T> x, T sign, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, sign, destination, TensorPrimitives.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 <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="sign">The <see cref="ReadOnlyTensorSpan{T}"/> with the associated signs.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> CopySign<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> sign, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, sign, destination, TensorPrimitives.CopySign);
-        }
-        #endregion
-
-        #region Cos
-        /// <summary>
-        /// Takes the cosine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the cosine of.</param>
-        public static Tensor<T> Cos<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Cos(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the cosine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the cosine of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Cos<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Cos);
-        }
-        #endregion
-
-        #region Cosh
-        /// <summary>
-        /// Takes the hyperbolic cosine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the cosine of.</param>
-        public static Tensor<T> Cosh<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IHyperbolicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Cosh(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the hyperbolic cosine of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the cosine of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Cosh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IHyperbolicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Cosh);
-        }
-        #endregion
-
-        #region CosineSimilarity
-        /// <summary>
-        /// Compute cosine similarity between <paramref name="x"/> and <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">The first <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="y">The second <see cref="ReadOnlyTensorSpan{T}"/></param>
-        public static Tensor<T> CosineSimilarity<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IRootFunctions<T>
-        {
-            if (x.Rank != 2)
-                ThrowHelper.ThrowArgument_2DTensorRequired(nameof(x));
-
-            if (y.Rank != 2)
-                ThrowHelper.ThrowArgument_2DTensorRequired(nameof(y));
-
-            if (x.Lengths[1] != y.Lengths[1])
-                ThrowHelper.ThrowArgument_IncompatibleDimensions(x.Lengths[1], y.Lengths[1]);
-
-            nint dim1 = x.Lengths[0];
-            nint dim2 = y.Lengths[0];
-
-            T[] values = new T[dim1 * dim2];
-
-            Tensor<T> output = Tensor.Create<T>(values, [dim1, dim2]);
-
-            CosineSimilarity(x, y, output);
-
-            return output;
-        }
-
-        /// <summary>
-        /// Compute cosine similarity between <paramref name="x"/> and <paramref name="y"/>.
-        /// </summary>
-        /// <param name="x">The first <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="y">The second <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> CosineSimilarity<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IRootFunctions<T>
-        {
-            if (x.Rank != 2)
-                ThrowHelper.ThrowArgument_2DTensorRequired(nameof(x));
-
-            if (y.Rank != 2)
-                ThrowHelper.ThrowArgument_2DTensorRequired(nameof(y));
-
-            if (x.Lengths[1] != y.Lengths[1])
-                ThrowHelper.ThrowArgument_IncompatibleDimensions(x.Lengths[1], y.Lengths[1]);
-
-            nint dim1 = x.Lengths[0];
-            nint dim2 = y.Lengths[0];
-
-            if (destination.Lengths[0] != dim1 || destination.Lengths[1] != dim2)
-                ThrowHelper.ThrowArgument_IncompatibleDimensions(x.Lengths[1], y.Lengths[1]);
-
-            Span<T> values = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-
-            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)x.Lengths[1];
-            for (int i = 0; i < dim1; i++)
-            {
-                for (int j = 0; j < dim2; j++)
-                {
-                    lspan = MemoryMarshal.CreateReadOnlySpan(ref Unsafe.Add(ref x._reference, TensorSpanHelpers.ComputeLinearIndex(leftIndexes, x.Strides, x.Lengths)), (int)rowLength);
-                    rspan = MemoryMarshal.CreateReadOnlySpan(ref Unsafe.Add(ref y._reference, TensorSpanHelpers.ComputeLinearIndex(rightIndexes, y.Strides, y.Lengths)), (int)rowLength);
-                    values[outputOffset++] = TensorPrimitives.CosineSimilarity(lspan, rspan);
-                    rightIndexes[0]++;
-                }
-                rightIndexes[0] = 0;
-                leftIndexes[0]++;
-            }
-
-            return ref destination;
-
-        }
-        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <remarks>
-        /// <para>
-        /// This method effectively computes <c><typeparamref name="T"/>.CosPi(<paramref name="x" />[i])</c>.
-        /// </para>
-        /// <para>
-        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians(System.Single)"/> 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>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            CosPi(x, output);
-            return output;
-        }
-
-        /// <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="x">The input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="destination"></param>
-        /// <remarks>
-        /// <para>
-        /// This method effectively computes <c><typeparamref name="T"/>.CosPi(<paramref name="x" />[i])</c>.
-        /// </para>
-        /// <para>
-        /// The angles in x must be in radians. Use <see cref="M:System.Single.DegreesToRadians(System.Single)"/> 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 ref readonly TensorSpan<T> CosPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.CosPi);
-        }
-        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> DegreesToRadians<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            DegreesToRadians(x, output);
-            return output;
-        }
-
-        /// <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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> DegreesToRadians<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.DegreesToRadians);
-        }
-        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static T Distance<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y)
-            where T : IRootFunctions<T>
-        {
-            return TensorPrimitivesHelperTwoSpanInTOut(x, y, TensorPrimitives.Distance);
-        }
-        #endregion
-
-        #region Divide
-        /// <summary>
-        /// Divides each element of <paramref name="x"/> by <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The divisor</param>
-        public static Tensor<T> Divide<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IDivisionOperators<T, T, T>
-        {
-            Tensor<T> output = Create<T>(x.Lengths);
-            Divide(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Divides <paramref name="x"/> by each element of <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result."/>
-        /// </summary>
-        /// <param name="x">The value to be divided.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
-        public static Tensor<T> Divide<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IDivisionOperators<T, T, T>
-        {
-            Tensor<T> output = Tensor.Create<T>(y.Lengths);
-            Divide(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Divides each element of <paramref name="x"/> by its corresponding element in <paramref name="y"/> and returns
-        /// a new <see cref="ReadOnlyTensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to be divided.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
-        public static Tensor<T> Divide<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IDivisionOperators<T, T, T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Divide(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Divides each element of <paramref name="x"/> by <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The divisor</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Divide<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IDivisionOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.Divide);
-        }
-
-        /// <summary>
-        /// Divides <paramref name="x"/> by each element of <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result."/>
-        /// </summary>
-        /// <param name="x">The value to be divided.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Divide<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IDivisionOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperTInSpanInSpanOut(x, y, destination, TensorPrimitives.Divide);
-        }
-
-        /// <summary>
-        /// Divides each element of <paramref name="x"/> by its corresponding element in <paramref name="y"/> and returns
-        /// a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to be divided.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> divisor.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Divide<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IDivisionOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Divide);
-        }
-        #endregion
-
-        #region Dot
-        /// <summary>
-        /// Computes the dot product of two tensors containing numbers.
-        /// </summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static T Dot<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplicativeIdentity<T, T>, IMultiplyOperators<T, T, T>
-        {
-            return TensorPrimitivesHelperTwoSpanInTOut(x, y, 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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Exp<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IExponentialFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Exp(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Computes the element-wise result of raising <c>e</c> to the single-precision floating-point number powers in the specified tensor.
-        /// </summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Exp<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IExponentialFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Exp);
-        }
-        #endregion
-
-        #region Exp10
-        /// <summary>
-        /// Computes the element-wise result of raising 10 to the number powers in the specified tensor.
-        /// </summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Exp10<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IExponentialFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Exp10(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Computes the element-wise result of raising 10 to the number powers in the specified tensor.
-        /// </summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Exp10<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IExponentialFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Exp10);
-        }
-        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Exp10M1<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IExponentialFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Exp10M1(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise result of raising 10 to the number powers in the specified tensor, minus one.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Exp10M1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IExponentialFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Exp10M1);
-        }
-        #endregion
-
-        #region Exp2
-        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Exp2<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IExponentialFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Exp2(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Exp2<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IExponentialFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Exp2);
-        }
-        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Exp2M1<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IExponentialFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Exp2M1(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise result of raising 2 to the number powers in the specified tensor, minus one.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Exp2M1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IExponentialFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Exp2M1);
-        }
-        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> ExpM1<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IExponentialFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            ExpM1(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise result of raising <c>e</c> to the number powers in the specified tensor, minus 1.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> ExpM1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IExponentialFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.ExpM1);
-        }
-        #endregion
-
-        #region Floor
-        /// <summary>Computes the element-wise floor of numbers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Floor<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IFloatingPoint<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Floor(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise floor of numbers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Floor<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IFloatingPoint<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Floor);
-        }
-        #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="x">Left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Hypot<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IRootFunctions<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Hypot(x, y, output);
-            return output;
-        }
-
-        /// <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="x">Left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Hypot<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IRootFunctions<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Hypot);
-        }
-        #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="x">Left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Ieee754Remainder<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IFloatingPointIeee754<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Ieee754Remainder(x, y, output);
-            return output;
-        }
-
-        /// <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="x">Left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Ieee754Remainder<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IFloatingPointIeee754<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Ieee754Remainder);
-        }
-
-        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Ieee754Remainder<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IFloatingPointIeee754<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-
-            Ieee754Remainder(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Ieee754Remainder<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IFloatingPointIeee754<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.Ieee754Remainder);
-        }
-
-        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Ieee754Remainder<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IFloatingPointIeee754<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(y.Lengths);
-
-            Ieee754Remainder(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise remainder of the numbers in the specified tensors.</summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Ieee754Remainder<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IFloatingPointIeee754<T>
-        {
-            return ref TensorPrimitivesHelperTInSpanInSpanOut(x, y, destination, TensorPrimitives.Ieee754Remainder);
-        }
-        #endregion
-
-        #region ILogB
-        /// <summary>Computes the element-wise integer logarithm of numbers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<int> ILogB<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IFloatingPointIeee754<T>
-        {
-            Tensor<int> output = Tensor.Create<int>(x.Lengths, x.Strides);
-            ILogB(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise integer logarithm of numbers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<int> ILogB<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<int> destination)
-            where T : IFloatingPointIeee754<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.ILogB);
-        }
-        #endregion
-
-        #region IndexOfMax
-        /// <summary>Searches for the index of the largest number in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static int IndexOfMax<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumber<T>
-        {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength);
-            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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static int IndexOfMaxMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumber<T>
-        {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength);
-            return TensorPrimitives.IndexOfMaxMagnitude(span);
-        }
-        #endregion
-
-        #region IndexOfMin
-        /// <summary>Searches for the index of the smallest number in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static int IndexOfMin<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumber<T>
-        {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength);
-            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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static int IndexOfMinMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumber<T>
-        {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength);
-            return TensorPrimitives.IndexOfMinMagnitude(span);
-        }
-        #endregion
-
-        #region LeadingZeroCount
-        /// <summary>
-        /// Computes the element-wise leading zero count of numbers in the specified tensor.
-        /// </summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> LeadingZeroCount<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IBinaryInteger<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            LeadingZeroCount(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Computes the element-wise leading zero count of numbers in the specified tensor.
-        /// </summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> LeadingZeroCount<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IBinaryInteger<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.LeadingZeroCount);
-        }
-        #endregion
-
-        #region Log
-        /// <summary>
-        /// Takes the natural logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the natural logarithm of.</param>
-        public static Tensor<T> Log<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ILogarithmicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Log(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the natural logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the natural logarithm of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Log<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ILogarithmicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Log);
-        }
-
-        /// <summary>Computes the element-wise logarithm of the numbers in a specified tensor to the specified base in another specified tensor.</summary>
-        /// <param name="x">The first tensor</param>
-        /// <param name="y">The second tensor</param>
-        public static Tensor<T> Log<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : ILogarithmicFunctions<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Log(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise logarithm of the numbers in a specified tensor to the specified base in another specified tensor.</summary>
-        /// <param name="x">The first tensor</param>
-        /// <param name="y">The second tensor</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> Log<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : ILogarithmicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Log);
-        }
-
-        /// <summary>Computes the element-wise logarithm of the numbers in a specified tensor to the specified base in another specified tensor.</summary>
-        /// <param name="x">The first tensor</param>
-        /// <param name="y">The second tensor</param>
-        public static Tensor<T> Log<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : ILogarithmicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-
-            Log(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise logarithm of the numbers in a specified tensor to the specified base in another specified tensor.</summary>
-        /// <param name="x">The first tensor</param>
-        /// <param name="y">The second tensor</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> Log<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : ILogarithmicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.Log);
-        }
-        #endregion
-
-        #region Log10
-        /// <summary>
-        /// Takes the base 10 logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 10 logarithm of.</param>
-        public static Tensor<T> Log10<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ILogarithmicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Log10(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the base 10 logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 10 logarithm of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Log10<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ILogarithmicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Log10);
-        }
-        #endregion
-
-        #region Log10P1
-        /// <summary>
-        /// Takes the base 10 logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 10 logarithm of.</param>
-        public static Tensor<T> Log10P1<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ILogarithmicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Log10P1(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the base 10 logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 10 logarithm of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Log10P1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ILogarithmicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Log10P1);
-        }
-        #endregion
-
-        #region Log2
-        /// <summary>
-        /// Takes the base 2 logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 2 logarithm of.</param>
-        public static Tensor<T> Log2<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ILogarithmicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Log2(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the base 2 logarithm of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 2 logarithm of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Log2<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ILogarithmicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Log2);
-        }
-        #endregion
-
-        #region Log2P1
-        /// <summary>
-        /// Takes the base 2 logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 2 logarithm of.</param>
-        public static Tensor<T> Log2P1<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ILogarithmicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Log2P1(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the base 2 logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the base 2 logarithm of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Log2P1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ILogarithmicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Log2P1);
-        }
-        #endregion
-
-        #region LogP1
-        /// <summary>
-        /// Takes the natural logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the natural logarithm of.</param>
-        public static Tensor<T> LogP1<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ILogarithmicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            LogP1(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the natural logarithm plus 1 of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the natural logarithm of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> LogP1<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ILogarithmicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.LogP1);
-        }
-        #endregion
-
-        #region Max
-        /// <summary>Searches for the largest number in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
-        public static T Max<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumber<T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.Max);
-        }
-
-        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> Max<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : INumber<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Max(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> Max<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Max);
-        }
-
-        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> Max<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : INumber<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Max(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> Max<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.Max);
-        }
-        #endregion
-
-        #region MaxMagnitude
-        /// <summary>Searches for the number with the largest magnitude in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
-        public static T MaxMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumber<T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.MaxMagnitude);
-        }
-
-        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MaxMagnitude<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : INumber<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            MaxMagnitude(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MaxMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.MaxMagnitude);
-        }
-
-        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MaxMagnitude<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : INumber<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            MaxMagnitude(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MaxMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.MaxMagnitude);
-        }
-        #endregion
-
-        #region MaxMagnitudeNumber
-        /// <summary>Searches for the number with the largest magnitude in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
-        public static T MaxMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumberBase<T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.MaxMagnitudeNumber);
-        }
-
-        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MaxMagnitudeNumber<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : INumber<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            MaxMagnitudeNumber(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MaxMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.MaxMagnitudeNumber);
-        }
-
-        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MaxMagnitudeNumber<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : INumber<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            MaxMagnitudeNumber(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise number with the largest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MaxMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.MaxMagnitudeNumber);
-        }
-        #endregion
-
-        #region MaxNumber
-        /// <summary>Searches for the largest number in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
-        public static T MaxNumber<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumber<T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.MaxNumber);
-        }
-
-        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MaxNumber<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : INumber<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            MaxNumber(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MaxNumber<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.MaxNumber);
-        }
-
-        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MaxNumber<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : INumber<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            MaxNumber(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise maximum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MaxNumber<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.MaxNumber);
-        }
-        #endregion
-
-        #region Min
-        /// <summary>Searches for the smallest number in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static T Min<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumber<T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.Min);
-        }
-
-        /// <summary>Computes the element-wise minimum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> Min<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : INumber<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Min(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise minimum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> Min<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Min);
-        }
-
-        /// <summary>Computes the element-wise minimum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> Min<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : INumber<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Min(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise minimum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> Min<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.Min);
-        }
-        #endregion
-
-        #region MinMagnitude
-        /// <summary>Searches for the number with the smallest magnitude in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static T MinMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumber<T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.MinMagnitude);
-        }
-
-        /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MinMagnitude<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : INumber<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            MinMagnitude(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MinMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.MinMagnitude);
-        }
-
-        /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MinMagnitude<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : INumber<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            MinMagnitude(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MinMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.MinMagnitude);
-        }
-        #endregion
-
-        #region MinMagnitudeNumber
-        /// <summary>Searches for the number with the smallest magnitude in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>..</param>
-        public static T MinMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumberBase<T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.MinMagnitudeNumber);
-        }
-
-        /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MinMagnitudeNumber<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : INumber<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            MinMagnitudeNumber(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MinMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.MinMagnitudeNumber);
-        }
-
-        /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MinMagnitudeNumber<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : INumber<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            MinMagnitudeNumber(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise number with the smallest magnitude in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MinMagnitudeNumber<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.MinMagnitudeNumber);
-        }
-        #endregion
-
-        #region MinNumber
-        /// <summary>Searches for the smallest number in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="TensorSpan{T}"/>..</param>
-        public static T MinNumber<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : INumber<T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.MinNumber);
-        }
-
-        /// <summary>Computes the element-wise minimum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MinNumber<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : INumber<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            MinNumber(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise minimum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MinNumber<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.MinNumber);
-        }
-
-        /// <summary>Computes the element-wise minimum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        public static Tensor<T> MinNumber<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : INumber<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            MinNumber(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise minimum of the numbers in the specified tensors.</summary>
-        /// <param name="x">The first tensor, represented as a span.</param>
-        /// <param name="y">The second tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        public static ref readonly TensorSpan<T> MinNumber<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : INumber<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.MinNumber);
-        }
-        #endregion
-
-        #region Multiply
-        /// <summary>
-        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="y"><typeparamref name="T"/> value to multiply by.</param>
-        public static Tensor<T> Multiply<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Multiply((ReadOnlyTensorSpan<T>)x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> 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="x">Left <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
-        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
-        public static Tensor<T> Multiply<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Multiply((ReadOnlyTensorSpan<T>)x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">Input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="y"><typeparamref name="T"/> value to multiply by.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Multiply<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
-        {
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-            TensorPrimitives.Multiply(span, y, ospan);
-            return ref destination;
-        }
-
-        /// <summary>
-        /// Multiplies each element of <paramref name="x"/> with <paramref name="y"/> 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="x">Left <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
-        /// <param name="y">Right <see cref="ReadOnlyTensorSpan{T}"/> for multiplication.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Multiply<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Multiply);
-        }
-        #endregion
-
-        #region Negate
-        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
-        public static Tensor<T> Negate<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IUnaryNegationOperators<T, T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Negate(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise negation of each number in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Negate<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IUnaryNegationOperators<T, T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Negate);
-        }
-        #endregion
-
-        #region Norm
-        /// <summary>
-        ///  Takes the norm of the <see cref="ReadOnlyTensorSpan{T}"/> and returns the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the norm of.</param>
-        public static T Norm<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : IRootFunctions<T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.Norm);
-        }
-        #endregion
-
-        #region OnesComplement
-        /// <summary>Computes the element-wise one's complement of numbers in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
-        public static Tensor<T> OnesComplement<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            OnesComplement(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise one's complement of numbers in the specified tensor.</summary>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> OnesComplement<T>(scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(y, destination, TensorPrimitives.OnesComplement);
-        }
-        #endregion
-
-        #region PopCount
-        /// <summary>Computes the element-wise population count of numbers in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/></param>
-        public static Tensor<T> PopCount<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IBinaryInteger<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            PopCount(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise population count of numbers in the specified tensor.</summary>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> PopCount<T>(scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IBinaryInteger<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(y, destination, TensorPrimitives.PopCount);
-        }
-        #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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        public static Tensor<T> Pow<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IPowerFunctions<T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Pow(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Pow<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IPowerFunctions<T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, 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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second input</param>
-        public static Tensor<T> Pow<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IPowerFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-
-            Pow(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Pow<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IPowerFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, 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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second input</param>
-        public static Tensor<T> Pow<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : IPowerFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(y.Lengths);
-
-            Pow(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise power of a number in a specified tensor raised to a number in another specified tensors.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second input <see cref="ReadOnlyTensorSpan{T}"/></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Pow<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IPowerFunctions<T>
-        {
-            return ref TensorPrimitivesHelperTInSpanInSpanOut(x, y, destination, TensorPrimitives.Pow);
-        }
-        #endregion
-
-        #region Product
-        /// <summary>Computes the product of all elements in the specified non-empty tensor of numbers.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static T Product<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : IMultiplicativeIdentity<T, T>, IMultiplyOperators<T, T, T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, 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="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> RadiansToDegrees<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            RadiansToDegrees(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise conversion of each number of radians in the specified tensor to degrees.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> RadiansToDegrees<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.RadiansToDegrees);
-        }
-        #endregion
-
-        #region Reciprocal
-        /// <summary>Computes the element-wise reciprocal of numbers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Reciprocal<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IFloatingPoint<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Reciprocal(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise reciprocal of numbers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Reciprocal<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IFloatingPoint<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Reciprocal);
-        }
-        #endregion
-
-        #region RootN
-        /// <summary>Computes the element-wise n-th root of the values in the specified tensor.</summary>
-        /// <param name="x">The tensor, represented as a span.</param>
-        /// <param name="n">The degree of the root to be computed, represented as a scalar.</param>
-        public static Tensor<T> RootN<T>(in ReadOnlyTensorSpan<T> x, int n)
-            where T : IRootFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            RootN(x, n, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise n-th root of the values in the specified tensor.</summary>
-        /// <param name="x">The tensor, represented as a span.</param>
-        /// <param name="destination">The destination tensor, represented as a span.</param>
-        /// <param name="n">The degree of the root to be computed, represented as a scalar.</param>
-        public static ref readonly TensorSpan<T> RootN<T>(scoped in ReadOnlyTensorSpan<T> x, int n, in TensorSpan<T> destination)
-            where T : IRootFunctions<T>
-        {
-            if (destination._shape._memoryLength < x._shape._memoryLength)
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-            TensorPrimitives.RootN(span, n, ospan);
-            return ref destination;
-        }
-        #endregion
-
-        #region RotateLeft
-        /// <summary>Computes the element-wise rotation left of numbers in the specified tensor by the specified rotation amount.</summary>
-        /// <param name="x">The tensor</param>
-        /// <param name="rotateAmount">The number of bits to rotate, represented as a scalar.</param>
-        /// <exception cref="ArgumentException">Destination is too short.</exception>
-        public static Tensor<T> RotateLeft<T>(in ReadOnlyTensorSpan<T> x, int rotateAmount)
-            where T : IBinaryInteger<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            RotateLeft(x, rotateAmount, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise rotation left of numbers in the specified tensor by the specified rotation amount.</summary>
-        /// <param name="x">The tensor</param>
-        /// <param name="rotateAmount">The number of bits to rotate, represented as a scalar.</param>
-        /// <param name="destination"></param>
-        /// <exception cref="ArgumentException">Destination is too short.</exception>
-        public static ref readonly TensorSpan<T> RotateLeft<T>(scoped in ReadOnlyTensorSpan<T> x, int rotateAmount, in TensorSpan<T> destination)
-            where T : IBinaryInteger<T>
-        {
-            if (destination._shape._memoryLength < x._shape._memoryLength)
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-            TensorPrimitives.RotateLeft(span, rotateAmount, ospan);
-            return ref destination;
-        }
-        #endregion
-
-        #region RotateRight
-        /// <summary>Computes the element-wise rotation right of numbers in the specified tensor by the specified rotation amount.</summary>
-        /// <param name="x">The tensor</param>
-        /// <param name="rotateAmount">The number of bits to rotate, represented as a scalar.</param>
-        /// <exception cref="ArgumentException">Destination is too short.</exception>
-        public static Tensor<T> RotateRight<T>(in ReadOnlyTensorSpan<T> x, int rotateAmount)
-            where T : IBinaryInteger<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            RotateRight(x, rotateAmount, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise rotation right of numbers in the specified tensor by the specified rotation amount.</summary>
-        /// <param name="x">The tensor</param>
-        /// <param name="rotateAmount">The number of bits to rotate, represented as a scalar.</param>
-        /// <param name="destination"></param>
-        /// <exception cref="ArgumentException">Destination is too short.</exception>
-        public static ref readonly TensorSpan<T> RotateRight<T>(scoped in ReadOnlyTensorSpan<T> x, int rotateAmount, in TensorSpan<T> destination)
-            where T : IBinaryInteger<T>
-        {
-            if (destination._shape._memoryLength < x._shape._memoryLength)
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-            TensorPrimitives.RotateRight(span, rotateAmount, ospan);
-            return ref destination;
-        }
-        #endregion
-
-        #region Round
-        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Round<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IFloatingPoint<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Round(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Round<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IFloatingPoint<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Round);
-        }
-
-        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="digits"></param>
-        /// <param name="mode"></param>
-        public static Tensor<T> Round<T>(in ReadOnlyTensorSpan<T> x, int digits, MidpointRounding mode)
-            where T : IFloatingPoint<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Round(x, digits, mode, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="digits"></param>
-        /// <param name="mode"></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Round<T>(scoped in ReadOnlyTensorSpan<T> x, int digits, MidpointRounding mode, in TensorSpan<T> destination)
-            where T : IFloatingPoint<T>
-        {
-            if (destination._shape._memoryLength < x._shape._memoryLength)
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-            TensorPrimitives.Round(span, digits, mode, ospan);
-            return ref destination;
-        }
-
-        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="digits"></param>
-        public static Tensor<T> Round<T>(in ReadOnlyTensorSpan<T> x, int digits)
-            where T : IFloatingPoint<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Round(x, digits, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="digits"></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Round<T>(scoped in ReadOnlyTensorSpan<T> x, int digits, in TensorSpan<T> destination)
-            where T : IFloatingPoint<T>
-        {
-            if (destination._shape._memoryLength < x._shape._memoryLength)
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-            TensorPrimitives.Round(span, digits, ospan);
-            return ref destination;
-        }
-
-        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="mode"></param>
-        public static Tensor<T> Round<T>(in ReadOnlyTensorSpan<T> x, MidpointRounding mode)
-            where T : IFloatingPoint<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Round(x, mode, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise rounding of the numbers in the specified tensor</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="mode"></param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Round<T>(scoped in ReadOnlyTensorSpan<T> x, MidpointRounding mode, in TensorSpan<T> destination)
-            where T : IFloatingPoint<T>
-        {
-            if (destination._shape._memoryLength < x._shape._memoryLength)
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-            TensorPrimitives.Round(span, mode, ospan);
-            return ref destination;
-        }
-        #endregion
-
-        #region Sigmoid
-        /// <summary>Computes the element-wise sigmoid function on the specified non-empty tensor of numbers.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Sigmoid<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IExponentialFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Sigmoid(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise sigmoid function on the specified non-empty tensor of numbers.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Sigmoid<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IExponentialFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Sigmoid);
-        }
-        #endregion
-
-        #region Sin
-        /// <summary>
-        /// Takes the sin of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> Sin<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Sin(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the sin of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Sin<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Sin);
-        }
-        #endregion
-
-        #region Sinh
-        /// <summary>Computes the element-wise hyperbolic sine of each radian angle in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> Sinh<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IHyperbolicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Sinh(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise hyperbolic sine of each radian angle in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Sinh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IHyperbolicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Sinh);
-        }
-        #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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> SinPi<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            SinPi(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise sine of the value in the specified tensor that has been multiplied by Pi.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> SinPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.SinPi);
-        }
-        #endregion
-
-        #region SoftMax
-        /// <summary>Computes the softmax function over the specified non-empty tensor of numbers.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> SoftMax<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IExponentialFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            SoftMax(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the softmax function over the specified non-empty tensor of numbers.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> SoftMax<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IExponentialFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.SoftMax);
-        }
-        #endregion
-
-        #region Sqrt
-        /// <summary>
-        /// Takes the square root of each element of the <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the square root of.</param>
-        public static Tensor<T> Sqrt<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IRootFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Sqrt(x, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Takes the square root of each element of the <paramref name="x"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the square root of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Sqrt<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IRootFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Sqrt);
-        }
-        #endregion
-
-        #region StdDev
-        /// <summary>
-        /// Returns the standard deviation of the elements in the <paramref name="x"/> tensor.
-        /// </summary>
-        /// <param name="x">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>(in ReadOnlyTensorSpan<T> x)
-            where T : IRootFunctions<T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.StdDev);
-        }
-        #endregion
-
-        #region Subtract
-        /// <summary>
-        /// Subtracts <paramref name="y"/> from each element of <paramref name="x"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The <typeparamref name="T"/> to subtract.</param>
-        public static Tensor<T> Subtract<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            Tensor<T> output = Create<T>(x.Lengths);
-            Subtract(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Subtracts each element of <paramref name="y"/> from <paramref name="x"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <typeparamref name="T"/> to be subtracted from.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> of values to subtract.</param>
-        public static Tensor<T> Subtract<T>(T x, in ReadOnlyTensorSpan<T> y)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            Tensor<T> output = Create<T>(y.Lengths);
-            Subtract(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Subtracts each element of <paramref name="x"/> from <paramref name="y"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> with values to be subtracted from.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> with values to subtract.</param>
-        public static Tensor<T> Subtract<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Subtract(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Subtracts <paramref name="y"/> from each element of <paramref name="x"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> with values to be subtracted from.</param>
-        /// <param name="y">The <typeparamref name="T"/> value to subtract.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Subtract<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.Subtract);
-        }
-
-        /// <summary>
-        /// Subtracts each element of <paramref name="y"/> from <paramref name="x"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <typeparamref name="T"/> value to be subtracted from.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/> values to subtract.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Subtract<T>(T x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperTInSpanInSpanOut(x, y, destination, TensorPrimitives.Subtract);
-        }
-
-        /// <summary>
-        /// Subtracts each element of <paramref name="x"/> from <paramref name="y"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> of values to be subtracted from.</param>
-        /// <param name="y">The <see cref="ReadOnlyTensorSpan{T}"/>of values to subtract.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Subtract<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : ISubtractionOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Subtract);
-        }
-        #endregion
-
-        #region Sum
-        /// <summary>
-        /// Sums the elements of the specified tensor.
-        /// </summary>
-        /// <param name="x">Tensor to sum</param>
-        /// <returns></returns>
-        public static T Sum<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.Sum);
-        }
-        #endregion
-
-        #region SumOfSquares
-        /// <summary>
-        /// Sums the squared elements of the specified tensor.
-        /// </summary>
-        /// <param name="x">Tensor to sum squares of</param>
-        /// <returns></returns>
-        internal static T SumOfSquares<T>(scoped in ReadOnlyTensorSpan<T> x)
-            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T>
-        {
-            return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.SumOfSquares);
-        }
-        #endregion
-
-        #region Tan
-        /// <summary>Computes the element-wise tangent of the value in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> Tan<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Tan(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise tangent of the value in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Tan<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Tan);
-        }
-        #endregion
-
-        #region Tanh
-        /// <summary>Computes the element-wise hyperbolic tangent of each radian angle in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> Tanh<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IHyperbolicFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Tanh(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise hyperbolic tangent of each radian angle in the specified tensor.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Tanh<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IHyperbolicFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Tanh);
-        }
-        #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="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        public static Tensor<T> TanPi<T>(in ReadOnlyTensorSpan<T> x)
-            where T : ITrigonometricFunctions<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            TanPi(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise tangent of the value in the specified tensor that has been multiplied by Pi.</summary>
-        /// <param name="x">The <see cref="ReadOnlyTensorSpan{T}"/> to take the sin of.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> TanPi<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : ITrigonometricFunctions<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.TanPi);
-        }
-        #endregion
-
-        #region TrailingZeroCount
-        /// <summary>Computes the element-wise trailing zero count of numbers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> TrailingZeroCount<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IBinaryInteger<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            TrailingZeroCount(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise trailing zero count of numbers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> TrailingZeroCount<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IBinaryInteger<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.TrailingZeroCount);
-        }
-        #endregion
-
-        #region Truncate
-        /// <summary>Computes the element-wise truncation of numbers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Truncate<T>(in ReadOnlyTensorSpan<T> x)
-            where T : IFloatingPoint<T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Truncate(x, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise truncation of numbers in the specified tensor.</summary>
-        /// <param name="x">The input <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Truncate<T>(scoped in ReadOnlyTensorSpan<T> x, in TensorSpan<T> destination)
-            where T : IFloatingPoint<T>
-        {
-            return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.Truncate);
-        }
-        #endregion
-
-        #region Xor
-        /// <summary>Computes the element-wise XOR of numbers in the specified tensors.</summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        public static Tensor<T> Xor<T>(in ReadOnlyTensorSpan<T> x, in ReadOnlyTensorSpan<T> y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> output;
-            if (x.Lengths.SequenceEqual(y.Lengths))
-            {
-                output = Tensor.Create<T>(x.Lengths);
-            }
-            else
-            {
-                output = Tensor.Create<T>(GetSmallestBroadcastableLengths(x.Lengths, y.Lengths));
-            }
-
-            Xor(x, y, output);
-            return output;
-        }
-
-        /// <summary>Computes the element-wise XOR of numbers in the specified tensors.</summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The right <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Xor<T>(scoped in ReadOnlyTensorSpan<T> x, scoped in ReadOnlyTensorSpan<T> y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperTwoSpanInSpanOut(x, y, destination, TensorPrimitives.Xor);
-        }
-
-        /// <summary>
-        /// Computes the element-wise Xor of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="Tensor{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        public static Tensor<T> Xor<T>(in ReadOnlyTensorSpan<T> x, T y)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            Tensor<T> output = Tensor.Create<T>(x.Lengths);
-            Xor(x, y, output);
-            return output;
-        }
-
-        /// <summary>
-        /// Computes the element-wise Xor of the two input <see cref="ReadOnlyTensorSpan{T}"/> and returns a new <see cref="TensorSpan{T}"/> with the result.
-        /// </summary>
-        /// <param name="x">The left <see cref="ReadOnlyTensorSpan{T}"/>.</param>
-        /// <param name="y">The second value.</param>
-        /// <param name="destination"></param>
-        public static ref readonly TensorSpan<T> Xor<T>(scoped in ReadOnlyTensorSpan<T> x, T y, in TensorSpan<T> destination)
-            where T : IBitwiseOperators<T, T, T>
-        {
-            return ref TensorPrimitivesHelperSpanInTInSpanOut(x, y, destination, TensorPrimitives.Xor);
-        }
-        #endregion
-
-        /// <summary>
-        /// Gets the smallest broadcastable lengths for two shapes.
-        /// </summary>
-        /// <param name="shape1">The first shape to broadcast.</param>
-        /// <param name="shape2">The second shape to broadcast.</param>
-        /// <returns>The smallest lengths these shapes can be broadcast to.</returns>
-        /// <exception cref="ArgumentException">The lengths of <paramref name="shape1" /> and  <paramref name="shape2" /> are not broadcast compatible.</exception>
-        public static nint[] GetSmallestBroadcastableLengths(ReadOnlySpan<nint> shape1, ReadOnlySpan<nint> shape2)
-        {
-            if (!TensorHelpers.IsBroadcastableTo(shape1, shape2))
-                ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible();
-
-            nint[] intermediateShape = TensorHelpers.GetIntermediateShape(shape1, shape2.Length);
-            for (int i = 1; i <= shape1.Length; i++)
-            {
-                intermediateShape[^i] = Math.Max(intermediateShape[^i], shape1[^i]);
-            }
-            for (int i = 1; i <= shape2.Length; i++)
-            {
-                intermediateShape[^i] = Math.Max(intermediateShape[^i], shape2[^i]);
-            }
-
-            return intermediateShape;
-        }
-
-        #region TensorPrimitivesHelpers
-        private delegate void PerformCalculationSpanInSpanOut<TIn, TOut>(ReadOnlySpan<TIn> input, Span<TOut> output);
-
-        private delegate void PerformCalculationSpanInTInSpanOut<T>(ReadOnlySpan<T> input, T value, Span<T> output);
-
-        private delegate void PerformCalculationTInSpanInSpanOut<T>(T value, ReadOnlySpan<T> input, Span<T> output);
-
-        private delegate void PerformCalculationTwoSpanInSpanOut<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo, Span<T> output);
-
-        private delegate T PerformCalculationTwoSpanInTOut<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo);
-
-        private delegate T PerformCalculationSpanInTOut<T>(ReadOnlySpan<T> input);
-
-        private static T TensorPrimitivesHelperSpanInTOut<T>(scoped in ReadOnlyTensorSpan<T> input, PerformCalculationSpanInTOut<T> performCalculation)
-        {
-            if (TensorHelpers.IsContiguousAndDense(input))
-            {
-                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape.FlattenedLength);
-                return performCalculation(span);
-            }
-            // Flattening needs to happen
-            else
-            {
-                // TODO: Can optimize this to not need to realize the broadcasts
-                // That will need to be done on a per method basis.
-                nint flattenedLength = input.FlattenedLength;
-                T[] flattened = new T[flattenedLength];
-                input.FlattenTo(flattened);
-                return performCalculation(flattened);
-            }
-        }
-
-        private static T TensorPrimitivesHelperTwoSpanInTOut<T>(scoped in ReadOnlyTensorSpan<T> left, scoped in ReadOnlyTensorSpan<T> right, PerformCalculationTwoSpanInTOut<T> performCalculation)
-        {
-            // If sizes are the same.
-            if (TensorHelpers.IsContiguousAndDense(left) && TensorHelpers.IsContiguousAndDense(right) && TensorHelpers.AreLengthsTheSame(left, right))
-            {
-                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref left._reference, (int)left._shape.FlattenedLength);
-                ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref right._reference, (int)right._shape.FlattenedLength);
-                return performCalculation(span, rspan);
-            }
-            // 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.
-
-                // TODO: Can optimize this to not need to realize the broadcasts
-                // That will need to be done on a per method basis.
-                nint[] newLengths = Tensor.GetSmallestBroadcastableLengths(left.Lengths, right.Lengths);
-                nint newLength = TensorSpanHelpers.CalculateTotalLength(newLengths);
-                TensorSpan<T> broadcastedLeft = new TensorSpan<T>(new T[newLength], newLengths, ReadOnlySpan<nint>.Empty);
-                TensorSpan<T> broadcastedRight = new TensorSpan<T>(new T[newLength], newLengths, ReadOnlySpan<nint>.Empty);
-                BroadcastTo(left, broadcastedLeft);
-                BroadcastTo(right, broadcastedRight);
-
-                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 ref readonly TensorSpan<TOut> TensorPrimitivesHelperSpanInSpanOut<TIn, TOut>(scoped in ReadOnlyTensorSpan<TIn> input, in TensorSpan<TOut> destination, PerformCalculationSpanInSpanOut<TIn, TOut> performCalculation)
-        {
-            // Make sure destination has enough memory
-            if (destination._shape._memoryLength < input._shape.FlattenedLength)
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-
-            // Make sure destination shape works with input shape
-            TensorSpan<TOut> slicedDestination = destination.Slice(input._shape.Lengths);
-
-            Span<TOut> destinationSpan;
-            ReadOnlySpan<TIn> inputSpan;
-
-            // Memory is contiguous for both input and destination
-            if (TensorHelpers.IsContiguousAndDense(input) && TensorHelpers.IsContiguousAndDense<TOut>(slicedDestination))
-            {
-                inputSpan = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape.FlattenedLength);
-                destinationSpan = MemoryMarshal.CreateSpan(ref slicedDestination._reference, (int)slicedDestination._shape.FlattenedLength);
-                performCalculation(inputSpan, destinationSpan);
-            }
-            else
-            {
-                scoped Span<nint> curIndex;
-                nint[]? curIndexArray;
-                if (input.Lengths.Length > TensorShape.MaxInlineRank)
-                {
-                    curIndexArray = ArrayPool<nint>.Shared.Rent(input.Lengths.Length);
-                    curIndex = curIndexArray.AsSpan(0, input.Rank);
-                }
-                else
-                {
-                    curIndexArray = null;
-                    curIndex = stackalloc nint[input.Lengths.Length];
-                }
-                curIndex.Clear();
-
-                int copiedValues = 0;
-                nint rowLength = input.Lengths[^1];
-
-                while (copiedValues < slicedDestination.FlattenedLength)
-                {
-                    inputSpan = MemoryMarshal.CreateReadOnlySpan(in input[curIndex], (int)rowLength);
-                    destinationSpan = MemoryMarshal.CreateSpan(ref slicedDestination[curIndex], (int)rowLength);
-                    performCalculation(inputSpan, destinationSpan);
-                    copiedValues += (int)rowLength;
-                    TensorSpanHelpers.AdjustIndexes(input.Rank - 2, 1, curIndex, input.Lengths);
-                }
-
-                if (curIndexArray != null)
-                    ArrayPool<nint>.Shared.Return(curIndexArray);
-            }
-
-            return ref destination;
-        }
-
-        private static ref readonly TensorSpan<T> TensorPrimitivesHelperSpanInTInSpanOut<T>(scoped in ReadOnlyTensorSpan<T> input, T value, in TensorSpan<T> destination, PerformCalculationSpanInTInSpanOut<T> performCalculation)
-        {
-            if (destination._shape._memoryLength < input._shape.FlattenedLength)
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-
-            // Make sure destination shape works with input shape
-            TensorSpan<T> slicedDestination = destination.Slice(input._shape.Lengths);
-
-            ReadOnlySpan<T> inputSpan;
-            Span<T> destinationSpan;
-
-            if (TensorHelpers.IsContiguousAndDense(input) && TensorHelpers.IsContiguousAndDense<T>(slicedDestination))
-            {
-                inputSpan = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength);
-                destinationSpan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength);
-                performCalculation(inputSpan, value, destinationSpan);
-            }
-            else
-            {
-                scoped Span<nint> curIndex;
-                nint[]? curIndexArray;
-                if (input.Lengths.Length > TensorShape.MaxInlineRank)
-                {
-                    curIndexArray = ArrayPool<nint>.Shared.Rent(input.Lengths.Length);
-                    curIndex = curIndexArray.AsSpan(0, input.Rank);
-                }
-                else
-                {
-                    curIndexArray = null;
-                    curIndex = stackalloc nint[input.Lengths.Length];
-                }
-                curIndex.Clear();
-
-                int copiedValues = 0;
-                nint rowLength = input.Lengths[^1];
-
-                while (copiedValues < slicedDestination.FlattenedLength)
-                {
-                    inputSpan = MemoryMarshal.CreateReadOnlySpan(in input[curIndex], (int)rowLength);
-                    destinationSpan = MemoryMarshal.CreateSpan(ref slicedDestination[curIndex], (int)rowLength);
-                    performCalculation(inputSpan, value, destinationSpan);
-                    copiedValues += (int)rowLength;
-                    TensorSpanHelpers.AdjustIndexes(input.Rank - 2, 1, curIndex, input.Lengths);
-                }
-
-                if (curIndexArray != null)
-                    ArrayPool<nint>.Shared.Return(curIndexArray);
-            }
-
-            return ref destination;
-        }
-
-        private static ref readonly TensorSpan<T> TensorPrimitivesHelperTInSpanInSpanOut<T>(T value, scoped in ReadOnlyTensorSpan<T> input, in TensorSpan<T> destination, PerformCalculationTInSpanInSpanOut<T> performCalculation)
-        {
-            if (destination._shape._memoryLength < input._shape.FlattenedLength)
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-
-            // Make sure destination shape works with input shape
-            TensorSpan<T> slicedDestination = destination.Slice(input._shape.Lengths);
-
-            ReadOnlySpan<T> inputSpan;
-            Span<T> destinationSpan;
-
-            if (TensorHelpers.IsContiguousAndDense(input) && TensorHelpers.IsContiguousAndDense<T>(slicedDestination))
-            {
-                inputSpan = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape._memoryLength);
-                destinationSpan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength);
-                performCalculation(value, inputSpan, destinationSpan);
-            }
-            else
-            {
-                scoped Span<nint> curIndex;
-                nint[]? curIndexArray;
-                if (input.Lengths.Length > TensorShape.MaxInlineRank)
-                {
-                    curIndexArray = ArrayPool<nint>.Shared.Rent(input.Lengths.Length);
-                    curIndex = curIndexArray.AsSpan(0, input.Rank);
-                }
-                else
-                {
-                    curIndexArray = null;
-                    curIndex = stackalloc nint[input.Lengths.Length];
-                }
-                curIndex.Clear();
-
-                int copiedValues = 0;
-                nint rowLength = input.Lengths[^1];
-
-                while (copiedValues < slicedDestination.FlattenedLength)
-                {
-                    inputSpan = MemoryMarshal.CreateReadOnlySpan(in input[curIndex], (int)rowLength);
-                    destinationSpan = MemoryMarshal.CreateSpan(ref slicedDestination[curIndex], (int)rowLength);
-                    performCalculation(value, inputSpan, destinationSpan);
-                    copiedValues += (int)rowLength;
-                    TensorSpanHelpers.AdjustIndexes(input.Rank - 2, 1, curIndex, input.Lengths);
-                }
-
-                if (curIndexArray != null)
-                    ArrayPool<nint>.Shared.Return(curIndexArray);
-            }
-
-            return ref destination;
-        }
-
-        private static ref readonly TensorSpan<T> TensorPrimitivesHelperTwoSpanInSpanOut<T>(scoped in ReadOnlyTensorSpan<T> left, scoped in ReadOnlyTensorSpan<T> right, in TensorSpan<T> destination, PerformCalculationTwoSpanInSpanOut<T> performCalculation)
-        {
-            nint[] newSize = Tensor.GetSmallestBroadcastableLengths(left.Lengths, right.Lengths);
-
-            TensorSpan<T> slicedDestination = destination.Slice(newSize);
-
-            // If sizes are the same and memory is contiguous for all tensors
-            if (TensorHelpers.AreLengthsTheSame(left, right) && TensorHelpers.IsUnderlyingStorageSameSize(left, right) && TensorHelpers.IsContiguousAndDense(left)
-                && TensorHelpers.IsContiguousAndDense(right) && TensorHelpers.IsContiguousAndDense<T>(slicedDestination))
-            {
-                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref left._reference, left._shape._memoryLength <= left.FlattenedLength ? (int)left._shape._memoryLength : (int)left.FlattenedLength);
-                ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref right._reference, right._shape._memoryLength <= right.FlattenedLength ? (int)right._shape._memoryLength : (int)right.FlattenedLength);
-                Span<T> ospan = MemoryMarshal.CreateSpan(ref slicedDestination._reference, (int)slicedDestination._shape._memoryLength);
-                performCalculation(span, rspan, ospan);
-                return ref destination;
-            }
-            // 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)
-
-                ReadOnlyTensorSpan<T> broadcastedLeft = Tensor.LazyBroadcast(left, newSize);
-                ReadOnlyTensorSpan<T> broadcastedRight = Tensor.LazyBroadcast(right, newSize);
-
-                nint rowLength = newSize[^1];
-                Span<T> ospan;
-                ReadOnlySpan<T> ispan;
-                Span<T> buffer = new T[rowLength];
-
-                scoped Span<nint> curIndex;
-                nint[]? curIndexArray;
-                if (newSize.Length > TensorShape.MaxInlineRank)
-                {
-                    curIndexArray = ArrayPool<nint>.Shared.Rent(newSize.Length);
-                    curIndex = curIndexArray.AsSpan(0, newSize.Length);
-                }
-                else
-                {
-                    curIndexArray = null;
-                    curIndex = stackalloc nint[newSize.Length];
-                }
-                curIndex.Clear();
-
-                int outputOffset = 0;
-                // neither row contiguous
-                if (broadcastedLeft.Strides[^1] == 0 && broadcastedRight.Strides[^1] == 0)
-                {
-                    Span<T> buffer2 = new T[rowLength];
-
-                    while (outputOffset < slicedDestination.FlattenedLength)
-                    {
-                        ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref slicedDestination._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, slicedDestination.Strides, slicedDestination.Lengths)), (int)rowLength);
-                        buffer.Fill(broadcastedLeft[curIndex]);
-                        buffer2.Fill(broadcastedRight[curIndex]);
-                        performCalculation(buffer, buffer2, ospan);
-                        outputOffset += (int)rowLength;
-                        TensorSpanHelpers.AdjustIndexes(broadcastedLeft.Rank - 2, 1, curIndex, broadcastedLeft.Lengths);
-                    }
-                }
-                // tensor not row contiguous
-                else if (broadcastedLeft.Strides[^1] == 0)
-                {
-                    while (outputOffset < slicedDestination.FlattenedLength)
-                    {
-                        ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref slicedDestination._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, slicedDestination.Strides, slicedDestination.Lengths)), (int)rowLength);
-                        buffer.Fill(broadcastedLeft[curIndex]);
-                        ispan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref broadcastedRight._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, broadcastedRight.Strides, broadcastedRight.Lengths)), (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 < slicedDestination.FlattenedLength)
-                    {
-                        ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref slicedDestination._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, slicedDestination.Strides, slicedDestination.Lengths)), (int)rowLength);
-                        buffer.Fill(broadcastedRight[curIndex]);
-                        ispan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref broadcastedLeft._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, broadcastedLeft.Strides, broadcastedLeft.Lengths)), (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 < slicedDestination.FlattenedLength)
-                    {
-                        ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref slicedDestination._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, slicedDestination.Strides, slicedDestination.Lengths)), (int)rowLength);
-                        ispan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref broadcastedLeft._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, broadcastedLeft.Strides, broadcastedLeft.Lengths)), (int)rowLength);
-                        rspan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref broadcastedRight._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, broadcastedRight.Strides, broadcastedRight.Lengths)), (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 ref destination;
-        }
-
-        #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
deleted file mode 100644
index c368c65fd1c6d5..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorHelpers.cs
+++ /dev/null
@@ -1,124 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.InteropServices;
-
-namespace System.Numerics.Tensors
-{
-    [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
-    internal static class TensorHelpers
-    {
-        /// <summary>
-        /// Counts the number of true elements in a boolean filter tensor so we know how much space we will need.
-        /// </summary>
-        /// <param name="filter"></param>
-        /// <returns>How many boolean values are true.</returns>
-        public static nint CountTrueElements(scoped in ReadOnlyTensorSpan<bool> filter)
-        {
-            Span<bool> filterSpan = MemoryMarshal.CreateSpan(ref filter._reference, (int)filter._shape._memoryLength);
-            nint count = 0;
-            for (int i = 0; i < filterSpan.Length; i++)
-            {
-                if (filterSpan[i])
-                    count++;
-            }
-
-            return count;
-        }
-
-        internal static bool IsBroadcastableTo<T>(Tensor<T> tensor1, Tensor<T> tensor2)
-            where T : IEquatable<T>, IEqualityOperators<T, T, bool> => IsBroadcastableTo(tensor1.Lengths, tensor2.Lengths);
-
-        internal static bool IsBroadcastableTo(ReadOnlySpan<nint> lengths1, ReadOnlySpan<nint> lengths2)
-        {
-            int lengths1Index = lengths1.Length - 1;
-            int lengths2Index = lengths2.Length - 1;
-
-            bool areCompatible = true;
-
-            nint s1;
-            nint s2;
-
-            if (lengths1.Length == 0 || lengths2.Length == 0)
-                return false;
-
-            while (lengths1Index >= 0 || lengths2Index >= 0)
-            {
-                // if a dimension is missing in one of the shapes, it is considered to be 1
-                if (lengths1Index < 0)
-                    s1 = 1;
-                else
-                    s1 = lengths1[lengths1Index--];
-
-                if (lengths2Index < 0)
-                    s2 = 1;
-                else
-                    s2 = lengths2[lengths2Index--];
-
-                if (s1 == s2 || (s1 == 1 && s2 > 1) || (s2 == 1 && s1 > 1)) { }
-                else
-                {
-                    areCompatible = false;
-                    break;
-                }
-            }
-
-            return areCompatible;
-        }
-
-        internal static nint[] GetIntermediateShape(ReadOnlySpan<nint> shape1, int shape2Length)
-        {
-            int shape1Index = shape1.Length - 1;
-            int newShapeIndex = Math.Max(shape1.Length, shape2Length) - 1;
-            nint[] newShape = new nint[Math.Max(shape1.Length, shape2Length)];
-
-            while (newShapeIndex >= 0)
-            {
-                // if a dimension is missing in one of the shapes, it is considered to be 1
-                if (shape1Index < 0)
-                    newShape[newShapeIndex--] = 1;
-                else
-                    newShape[newShapeIndex--] = shape1[shape1Index--];
-            }
-
-            return newShape;
-        }
-
-        internal static bool IsUnderlyingStorageSameSize<T>(scoped in ReadOnlyTensorSpan<T> tensor1, scoped in ReadOnlyTensorSpan<T> tensor2)
-            => tensor1._shape._memoryLength == tensor2._shape._memoryLength;
-
-        internal static bool IsUnderlyingStorageSameSize<T>(Tensor<T> tensor1, Tensor<T> tensor2)
-    => tensor1._values.Length == tensor2._values.Length;
-
-        internal static bool AreLengthsTheSame<T>(scoped in ReadOnlyTensorSpan<T> tensor1, scoped in ReadOnlyTensorSpan<T> tensor2)
-            => tensor1.Lengths.SequenceEqual(tensor2.Lengths);
-
-        internal static bool AreLengthsTheSame(ReadOnlySpan<nint> lengths1, ReadOnlySpan<nint> lengths2)
-            => lengths1.SequenceEqual(lengths2);
-
-        internal static bool IsContiguousAndDense<T>(scoped in ReadOnlyTensorSpan<T> tensor)
-        {
-            // Right most dimension must be 1 for a dense tensor.
-            if (tensor._shape.Strides[^1] != 1)
-                return false;
-
-            // For other dimensions, the stride must be equal to the product of the dimensions to the right.
-            for (int i = tensor._shape._rank - 2; i >= 0; i--)
-            {
-                if (tensor._shape.Strides[i] != TensorPrimitives.Product(tensor.Lengths.Slice(i + 1, tensor.Lengths.Length - i - 1)))
-                    return false;
-            }
-            return true;
-        }
-
-        internal static void PermuteIndices(Span<nint> indices, Span<nint> permutedIndices, ReadOnlySpan<int> permutation)
-        {
-            for (int i = 0; i < indices.Length; i++)
-            {
-                permutedIndices[i] = indices[permutation[i]];
-            }
-        }
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
new file mode 100644
index 00000000000000..d372602f2fa429
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorOperation.cs
@@ -0,0 +1,2615 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace System.Numerics.Tensors
+{
+    internal static class TensorOperation
+    {
+        public static void Invoke<TOperation, T>(in TensorSpan<T> x)
+            where TOperation : TensorOperation.IOperation<T>
+        {
+            scoped Span<nint> indexes = RentedBuffer.Create(x.Rank, x.Strides, out nint linearOffset, out RentedBuffer<nint> rentedBuffer);
+
+            for (nint i = 0; i < x.FlattenedLength; i++)
+            {
+                linearOffset = x._shape.AdjustToNextIndex(x._shape, linearOffset, indexes);
+                TOperation.Invoke(
+                    ref Unsafe.Add(ref x._reference, linearOffset)
+                );
+            }
+
+            rentedBuffer.Dispose();
+        }
+
+        public static bool Invoke<TOperation, TArg>(in ReadOnlyTensorSpan<TArg> x, in ReadOnlyTensorSpan<TArg> y)
+            where TOperation : TensorOperation.IBinaryOperation_Tensor_Tensor<TArg, bool>
+        {
+            bool result = false;
+
+            ref readonly TensorShape destinationShape = ref ((x._shape.FlattenedLength > y._shape.FlattenedLength) ? ref x._shape : ref y._shape);
+            scoped Span<nint> xIndexes = RentedBuffer.Create(destinationShape.Rank, x.Strides, out nint xLinearOffset, out RentedBuffer<nint> xRentedBuffer);
+            scoped Span<nint> yIndexes = RentedBuffer.Create(destinationShape.Rank, y.Strides, out nint yLinearOffset, out RentedBuffer<nint> yRentedBuffer);
+
+            for (nint i = 0; i < destinationShape.FlattenedLength; i++)
+            {
+                xLinearOffset = x._shape.AdjustToNextIndex(destinationShape, xLinearOffset, xIndexes);
+                yLinearOffset = y._shape.AdjustToNextIndex(destinationShape, yLinearOffset, yIndexes);
+
+                 TOperation.Invoke(
+                    in Unsafe.Add(ref x._reference, xLinearOffset),
+                    in Unsafe.Add(ref y._reference, yLinearOffset),
+                    ref result
+                );
+
+                if (!result)
+                {
+                    break;
+                }
+            }
+
+            xRentedBuffer.Dispose();
+            yRentedBuffer.Dispose();
+
+            return result;
+        }
+
+        public static bool Invoke<TOperation, TArg>(in ReadOnlyTensorSpan<TArg> x, TArg y)
+            where TOperation : TensorOperation.IBinaryOperation_Tensor_Scalar<TArg, bool>
+        {
+            bool result = false;
+
+            scoped Span<nint> xIndexes = RentedBuffer.Create(x.Rank, x.Strides, out nint xLinearOffset, out RentedBuffer<nint> xRentedBuffer);
+
+            for (nint i = 0; i < x.FlattenedLength; i++)
+            {
+                xLinearOffset = x._shape.AdjustToNextIndex(x._shape, xLinearOffset, xIndexes);
+
+                TOperation.Invoke(
+                    in Unsafe.Add(ref x._reference, xLinearOffset),
+                    y,
+                    ref result
+                );
+
+                if (!result)
+                {
+                    return false;
+                }
+            }
+
+            xRentedBuffer.Dispose();
+
+            return result;
+        }
+
+        public static void Invoke<TOperation, TArg, TResult>(in TensorSpan<TResult> destination, TArg scalar)
+            where TOperation : TensorOperation.IUnaryOperation_Scalar<TArg, TResult>
+        {
+            scoped Span<nint> indexes = RentedBuffer.Create(destination.Rank, destination.Strides, out nint linearOffset, out RentedBuffer<nint> rentedBuffer);
+
+            for (nint i = 0; i < destination.FlattenedLength; i++)
+            {
+                linearOffset = destination._shape.AdjustToNextIndex(destination._shape, linearOffset, indexes);
+                TOperation.Invoke(
+                    ref Unsafe.Add(ref destination._reference, linearOffset),
+                    scalar
+                );
+            }
+
+            rentedBuffer.Dispose();
+        }
+
+        public static void Invoke<TOperation, TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, in TensorSpan<TResult> destination)
+            where TOperation : TensorOperation.IUnaryOperation_Tensor<TArg, TResult>
+        {
+            scoped Span<nint> xIndexes = RentedBuffer.Create(destination.Rank, x.Strides, out nint xLinearOffset, out RentedBuffer<nint> xRentedBuffer);
+            scoped Span<nint> destinationIndexes = RentedBuffer.Create(destination.Rank, destination.Strides, out nint destinationLinearOffset, out RentedBuffer<nint> destinationRentedBuffer);
+
+            for (nint i = 0; i < destination.FlattenedLength; i++)
+            {
+                xLinearOffset = x._shape.AdjustToNextIndex(destination._shape, xLinearOffset, xIndexes);
+                destinationLinearOffset = destination._shape.AdjustToNextIndex(destination._shape, destinationLinearOffset, destinationIndexes);
+
+                TOperation.Invoke(
+                    in Unsafe.Add(ref x._reference, xLinearOffset),
+                    ref Unsafe.Add(ref destination._reference, destinationLinearOffset)
+                );
+            }
+
+            xRentedBuffer.Dispose();
+            destinationRentedBuffer.Dispose();
+        }
+
+        public static void ReverseInvoke<TOperation, TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, in TensorSpan<TResult> destination)
+            where TOperation : TensorOperation.IUnaryOperation_Tensor<TArg, TResult>
+        {
+            scoped Span<nint> xIndexes = RentedBuffer.Create(destination.Rank, x.Strides, out nint xLinearOffset, out RentedBuffer<nint> xRentedBuffer);
+            scoped Span<nint> destinationIndexes = RentedBuffer.Create(destination.Rank, destination.Strides, out nint _, out RentedBuffer<nint> destinationRentedBuffer);
+
+            destinationIndexes[0] = destination.Lengths[0];
+            for (int i = 1; i < destinationIndexes.Length; i++)
+            {
+                destinationIndexes[i] = destination.Lengths[i] - 1;
+            }
+            nint destinationLinearOffset = destination._shape.LinearLength;
+
+            for (nint i = 0; i < destination.FlattenedLength; i++)
+            {
+                xLinearOffset = x._shape.AdjustToNextIndex(destination._shape, xLinearOffset, xIndexes);
+                destinationLinearOffset = destination._shape.AdjustToPreviousIndex(destination._shape, destinationLinearOffset, destinationIndexes);
+
+                TOperation.Invoke(
+                    in Unsafe.Add(ref x._reference, xLinearOffset),
+                    ref Unsafe.Add(ref destination._reference, destinationLinearOffset)
+                );
+            }
+
+            xRentedBuffer.Dispose();
+            destinationRentedBuffer.Dispose();
+        }
+
+        // For copyto/flattento
+        public static void Invoke<TOperation, TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, in Span<TResult> destination)
+            where TOperation : TensorOperation.IUnaryOperation_Tensor<TArg, TResult>
+        {
+            scoped Span<nint> xIndexes = RentedBuffer.Create(x.Rank, x.Strides, out nint xLinearOffset, out RentedBuffer<nint> xRentedBuffer);
+            nint destinationIndex = -1;
+
+            for (nint i = 0; i < destination.Length; i++)
+            {
+                xLinearOffset = x._shape.AdjustToNextIndex(x._shape, xLinearOffset, xIndexes);
+                destinationIndex++;
+
+                TOperation.Invoke(
+                    in Unsafe.Add(ref x._reference, xLinearOffset),
+                    ref Unsafe.Add(ref destination[0], destinationIndex)
+                );
+            }
+
+            xRentedBuffer.Dispose();
+        }
+
+        public static void Invoke<TOperation, TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, ref TResult destination)
+            where TOperation : TensorOperation.IUnaryReduction_Tensor<TArg, TResult>
+        {
+            scoped Span<nint> xIndexes = RentedBuffer.Create(x.Rank, x.Strides, out nint xLinearOffset, out RentedBuffer<nint> xRentedBuffer);
+
+            for (nint i = 0; i < x.FlattenedLength; i++)
+            {
+                xLinearOffset = x._shape.AdjustToNextIndex(x._shape, xLinearOffset, xIndexes);
+
+                TOperation.Invoke(
+                    in Unsafe.Add(ref x._reference, xLinearOffset),
+                    ref destination
+                );
+            }
+
+            xRentedBuffer.Dispose();
+        }
+
+        public static void Invoke<TOperation, TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, in ReadOnlyTensorSpan<TArg> y, in TensorSpan<TResult> destination)
+            where TOperation : TensorOperation.IBinaryOperation_Tensor_Tensor<TArg, TResult>
+        {
+            scoped Span<nint> xIndexes = RentedBuffer.Create(destination.Rank, x.Strides, out nint xLinearOffset, out RentedBuffer<nint> xRentedBuffer);
+            scoped Span<nint> yIndexes = RentedBuffer.Create(destination.Rank, y.Strides, out nint yLinearOffset, out RentedBuffer<nint> yRentedBuffer);
+            scoped Span<nint> destinationIndexes = RentedBuffer.Create(destination.Rank, destination.Strides, out nint destinationLinearOffset, out RentedBuffer<nint> destinationRentedBuffer);
+
+            for (nint i = 0; i < destination.FlattenedLength; i++)
+            {
+                xLinearOffset = x._shape.AdjustToNextIndex(destination._shape, xLinearOffset, xIndexes);
+                yLinearOffset = y._shape.AdjustToNextIndex(destination._shape, yLinearOffset, yIndexes);
+                destinationLinearOffset = destination._shape.AdjustToNextIndex(destination._shape, destinationLinearOffset, destinationIndexes);
+
+                TOperation.Invoke(
+                    in Unsafe.Add(ref x._reference, xLinearOffset),
+                    in Unsafe.Add(ref y._reference, yLinearOffset),
+                    ref Unsafe.Add(ref destination._reference, destinationLinearOffset)
+                );
+            }
+
+            xRentedBuffer.Dispose();
+            yRentedBuffer.Dispose();
+            destinationRentedBuffer.Dispose();
+        }
+
+        public static void Invoke<TOperation, TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, in ReadOnlyTensorSpan<TArg> y, ref TResult result)
+            where TOperation : TensorOperation.IBinaryOperation_Tensor_Tensor<TArg, TResult>
+        {
+            ref readonly TensorShape destinationShape = ref ((x._shape.FlattenedLength > y._shape.FlattenedLength) ? ref x._shape : ref y._shape);
+
+            scoped Span<nint> xIndexes = RentedBuffer.Create(destinationShape.Rank, x.Strides, out nint xLinearOffset, out RentedBuffer<nint> xRentedBuffer);
+            scoped Span<nint> yIndexes = RentedBuffer.Create(destinationShape.Rank, y.Strides, out nint yLinearOffset, out RentedBuffer<nint> yRentedBuffer);
+
+            for (nint i = 0; i < destinationShape.FlattenedLength; i++)
+            {
+                xLinearOffset = x._shape.AdjustToNextIndex(destinationShape, xLinearOffset, xIndexes);
+                yLinearOffset = y._shape.AdjustToNextIndex(destinationShape, yLinearOffset, yIndexes);
+
+                TOperation.Invoke(
+                    in Unsafe.Add(ref x._reference, xLinearOffset),
+                    in Unsafe.Add(ref y._reference, yLinearOffset),
+                    ref result
+                );
+            }
+
+            xRentedBuffer.Dispose();
+            yRentedBuffer.Dispose();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Invoke<TOperation, TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, TArg y, in TensorSpan<TResult> destination)
+            where TOperation : TensorOperation.IBinaryOperation_Tensor_Scalar<TArg, TResult> => Invoke<TOperation, TArg, TArg, TResult>(in x, y, in destination);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Invoke<TOperation, TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, int y, in TensorSpan<TResult> destination)
+            where TOperation : TensorOperation.IBinaryOperation_Tensor_Int32<TArg, TResult> => Invoke<TOperation, TArg, int, TResult>(in x, y, in destination);
+
+        public static void Invoke<TOperation, T1Arg, T2, TResult>(in ReadOnlyTensorSpan<T1Arg> x, T2 y, in TensorSpan<TResult> destination)
+            where TOperation : TensorOperation.IBinaryOperation_Tensor_Scalar<T1Arg, T2, TResult>
+        {
+            scoped Span<nint> xIndexes = RentedBuffer.Create(destination.Rank, x.Strides, out nint xLinearOffset, out RentedBuffer<nint> xRentedBuffer);
+            scoped Span<nint> destinationIndexes = RentedBuffer.Create(destination.Rank, destination.Strides, out nint destinationLinearOffset, out RentedBuffer<nint> destinationRentedBuffer);
+
+            for (nint i = 0; i < destination.FlattenedLength; i++)
+            {
+                xLinearOffset = x._shape.AdjustToNextIndex(destination._shape, xLinearOffset, xIndexes);
+                destinationLinearOffset = destination._shape.AdjustToNextIndex(destination._shape, destinationLinearOffset, destinationIndexes);
+
+                TOperation.Invoke(
+                    in Unsafe.Add(ref x._reference, xLinearOffset),
+                    y,
+                    ref Unsafe.Add(ref destination._reference, destinationLinearOffset)
+                );
+            }
+
+            xRentedBuffer.Dispose();
+            destinationRentedBuffer.Dispose();
+        }
+
+        public static void Invoke<TOperation, TArg, TResult>(TArg x, in ReadOnlyTensorSpan<TArg> y, in TensorSpan<TResult> destination)
+            where TOperation : TensorOperation.IBinaryOperation_Scalar_Tensor<TArg, TArg, TResult>
+        {
+            scoped Span<nint> xIndexes = RentedBuffer.Create(destination.Rank, y.Strides, out nint xLinearOffset, out RentedBuffer<nint> xRentedBuffer);
+            scoped Span<nint> destinationIndexes = RentedBuffer.Create(destination.Rank, destination.Strides, out nint destinationLinearOffset, out RentedBuffer<nint> destinationRentedBuffer);
+
+            for (nint i = 0; i < destination.FlattenedLength; i++)
+            {
+                xLinearOffset = y._shape.AdjustToNextIndex(destination._shape, xLinearOffset, xIndexes);
+                destinationLinearOffset = destination._shape.AdjustToNextIndex(destination._shape, destinationLinearOffset, destinationIndexes);
+
+                TOperation.Invoke(
+                    x,
+                    in Unsafe.Add(ref y._reference, xLinearOffset),
+                    ref Unsafe.Add(ref destination._reference, destinationLinearOffset)
+                );
+            }
+
+            xRentedBuffer.Dispose();
+            destinationRentedBuffer.Dispose();
+        }
+
+        public static void Invoke<TOperation, T1Arg, T2, TResult>(in ReadOnlyTensorSpan<T1Arg> x, T2 y, ref TResult result)
+            where TOperation : TensorOperation.IBinaryOperation_Tensor_Scalar<T1Arg, T2, TResult>
+        {
+            scoped Span<nint> xIndexes = RentedBuffer.Create(x.Rank, x.Strides, out nint xLinearOffset, out RentedBuffer<nint> xRentedBuffer);
+
+            for (nint i = 0; i < x.FlattenedLength; i++)
+            {
+                xLinearOffset = x._shape.AdjustToNextIndex(x._shape, xLinearOffset, xIndexes);
+
+                TOperation.Invoke(
+                    in Unsafe.Add(ref x._reference, xLinearOffset),
+                    y,
+                    ref result
+                );
+            }
+
+            xRentedBuffer.Dispose();
+        }
+
+        public static void Invoke<TOperation, TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, TArg y, ref TResult result)
+            where TOperation : TensorOperation.IBinaryOperation_Tensor_Scalar<TArg, TResult> => Invoke<TOperation, TArg, TArg, TResult>(in x, y, ref result);
+
+        public static void ValidateCompatibility<TArg>(in ReadOnlyTensorSpan<TArg> x, in ReadOnlySpan<nint> lengths)
+        {
+            // x can be broadcast to destination, not vice verse
+            if (!TensorShape.AreCompatible(lengths, x._shape))
+                ThrowHelper.ThrowArgument_LengthsNotCompatible();
+        }
+
+        public static void ValidateCompatibility<TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, in ReadOnlyTensorSpan<TResult> y)
+        {
+            // Can be bidirectional validation
+            if (!TensorShape.AreCompatible(x._shape, y._shape, true))
+                ThrowHelper.ThrowArgument_LengthsNotCompatible();
+        }
+
+        public static void ValidateCompatibility<TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, in TensorSpan<TResult> destination)
+        {
+            // x can be broadcast to destination, not vice verse
+            if (!TensorShape.AreCompatible(destination._shape, x._shape, false))
+                ThrowHelper.ThrowArgument_LengthsNotCompatible();
+        }
+
+        public static void ValidateCompatibility<TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, in ReadOnlyTensorSpan<TArg> y, in TensorSpan<TResult> destination)
+        {
+            // can do bidirectional validation between x and y, that result can then be broadcast to destination
+            if (TensorShape.AreCompatible(x._shape, y._shape, true))
+            {
+                if (TensorShape.AreCompatible(destination._shape, x._shape, false))
+                {
+                    if (TensorShape.AreCompatible(destination._shape, y._shape, false))
+                    {
+                        // all three are compatible
+                        return;
+                    }
+                }
+            }
+            ThrowHelper.ThrowArgument_LengthsNotCompatible();
+        }
+
+        public static void ValidateCompatibility<TArg, TResult>(in ReadOnlyTensorSpan<TArg> x, in ReadOnlyTensorSpan<TArg> y, out Tensor<TResult> destination)
+        {
+            // can do bidirectional validation between x and y, that result can then be broadcast to destination
+            if (TensorShape.AreCompatible(x._shape, y._shape, true))
+            {
+                if (x.Rank > y.Rank)
+                {
+                    destination = Tensor.CreateUninitialized<TResult>(x._shape.Lengths);
+                }
+                else
+                {
+                    destination = Tensor.CreateUninitialized<TResult>(y._shape.Lengths);
+                }
+                return;
+            }
+            destination = default!;
+            ThrowHelper.ThrowArgument_LengthsNotCompatible();
+        }
+
+        public readonly struct Clear<T>
+            : IOperation<T>
+        {
+            public static void Invoke(ref T destination)
+            {
+                destination = default!;
+            }
+
+            public static void Invoke(Span<T> destination)
+            {
+                destination.Clear();
+            }
+        }
+
+        public readonly struct CopyTo<T>
+            : IUnaryOperation_Tensor<T, T>
+        {
+            public static void Invoke(ref readonly T source, ref T destination)
+            {
+                destination = source;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> source, Span<T> destination)
+            {
+                source.CopyTo(destination);
+            }
+        }
+
+        public readonly struct Equals<T>
+            : IBinaryOperation_Tensor_Scalar<T, bool>,
+              IBinaryOperation_Tensor_Tensor<T, bool>
+            where T : IEqualityOperators<T, T, bool>
+        {
+            public static void Invoke(ref readonly T left, T right, ref bool destination)
+            {
+                destination = (left == right);
+            }
+
+            public static void Invoke(ref readonly T left, ref readonly T right, ref bool destination)
+            {
+                destination = (left == right);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, T right, Span<bool> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = (left[i] == right);
+                }
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, ReadOnlySpan<T> right, Span<bool> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = (left[i] == right[i]);
+                }
+            }
+        }
+
+        public readonly struct EqualsAny<T>
+            : IBinaryOperation_Tensor_Scalar<T, bool>,
+              IBinaryOperation_Tensor_Tensor<T, bool>
+            where T : IEqualityOperators<T, T, bool>
+        {
+            // The main loop early exits at the first false condition, so we
+            // check x != y and returns false on first equal. The consumer will
+            // then negate whatever the main loop returns as `true` means none
+            // are equal.
+
+            public static void Invoke(ref readonly T left, T right, ref bool destination)
+            {
+                destination = (left != right);
+            }
+
+            public static void Invoke(ref readonly T left, ref readonly T right, ref bool destination)
+            {
+                destination = (left != right);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, T right, Span<bool> destination)
+            {
+                Debug.Assert(destination.Length == 1);
+                bool result = false;
+
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    result = (left[i] != right);
+
+                    if (!result)
+                    {
+                        break;
+                    }
+                }
+
+                destination[0] = result;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, ReadOnlySpan<T> right, Span<bool> destination)
+            {
+                Debug.Assert(destination.Length == 1);
+                bool result = false;
+
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    result = (left[i] != right[i]);
+
+                    if (!result)
+                    {
+                        break;
+                    }
+                }
+
+                destination[0] = result;
+            }
+        }
+
+        #region TensorOperation Primitives
+        public readonly struct Abs<T>
+            : IUnaryOperation_Tensor<T, T>
+            where T : INumberBase<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Abs(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Abs(x, destination);
+            }
+        }
+
+        public readonly struct Acos<T>
+            : IUnaryOperation_Tensor<T, T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Acos(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Acos(x, destination);
+            }
+        }
+
+        public readonly struct Acosh<T>
+            : IUnaryOperation_Tensor<T, T>
+            where T : IHyperbolicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Acosh(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Acosh(x, destination);
+            }
+        }
+
+        public readonly struct AcosPi<T>
+            : IUnaryOperation_Tensor<T, T>
+            where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.AcosPi(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.AcosPi(x, destination);
+            }
+        }
+
+        public readonly struct Add<T>
+            : IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = x + y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.Add(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = x + y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Add(x, y, destination);
+            }
+        }
+
+        public readonly struct Asin<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Asin(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Asin(x, destination);
+            }
+        }
+
+        public readonly struct Asinh<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IHyperbolicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Asinh(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Asinh(x, destination);
+            }
+        }
+
+        public readonly struct AsinPi<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.AsinPi(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.AsinPi(x, destination);
+            }
+        }
+
+        public readonly struct Atan<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Atan(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Atan(x, destination);
+            }
+        }
+
+        public readonly struct Atan2<T>
+            : IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IFloatingPointIeee754<T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.Atan2(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = T.Atan2(x[i], y);
+                }
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.Atan2(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Atan2(x, y, destination);
+            }
+        }
+
+        public readonly struct Atan2Pi<T>
+            : IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IFloatingPointIeee754<T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.Atan2Pi(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = T.Atan2Pi(x[i], y);
+                }
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.Atan2Pi(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Atan2Pi(x, y, destination);
+            }
+        }
+
+        public readonly struct Atanh<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IHyperbolicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Atanh(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Atanh(x, destination);
+            }
+        }
+
+        public readonly struct AtanPi<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.AtanPi(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.AtanPi(x, destination);
+            }
+        }
+
+        public readonly struct BitwiseAnd<T>
+            : IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IBitwiseOperators<T, T, T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = x & y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.BitwiseAnd(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = x & y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.BitwiseAnd(x, y, destination);
+            }
+        }
+
+        public readonly struct BitwiseOr<T>
+            : IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IBitwiseOperators<T, T, T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = x | y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.BitwiseOr(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = x | y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.BitwiseOr(x, y, destination);
+            }
+        }
+
+        public readonly struct Cbrt<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IRootFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Cbrt(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Cbrt(x, destination);
+            }
+        }
+
+        public readonly struct Ceiling<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IFloatingPoint<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Ceiling(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Ceiling(x, destination);
+            }
+        }
+
+        public readonly struct ConvertChecked<TFrom, TTo>
+        : IUnaryOperation_Tensor<TFrom, TTo>
+        where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+        where TTo : INumberBase<TTo>
+        {
+            public static void Invoke(ref readonly TFrom x, ref TTo destination)
+            {
+                destination = TTo.CreateChecked(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<TFrom> x, Span<TTo> destination)
+            {
+                TensorPrimitives.ConvertChecked(x, destination);
+            }
+        }
+
+        public readonly struct ConvertSaturating<TFrom, TTo>
+        : IUnaryOperation_Tensor<TFrom, TTo>
+        where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+        where TTo : INumberBase<TTo>
+        {
+            public static void Invoke(ref readonly TFrom x, ref TTo destination)
+            {
+                destination = TTo.CreateSaturating(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<TFrom> x, Span<TTo> destination)
+            {
+                TensorPrimitives.ConvertSaturating(x, destination);
+            }
+        }
+
+        public readonly struct ConvertTruncating<TFrom, TTo>
+        : IUnaryOperation_Tensor<TFrom, TTo>
+        where TFrom : IEquatable<TFrom>, IEqualityOperators<TFrom, TFrom, bool>, INumberBase<TFrom>
+        where TTo : INumberBase<TTo>
+        {
+            public static void Invoke(ref readonly TFrom x, ref TTo destination)
+            {
+                destination = TTo.CreateTruncating(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<TFrom> x, Span<TTo> destination)
+            {
+                TensorPrimitives.ConvertTruncating(x, destination);
+            }
+        }
+
+        public readonly struct CopySign<T>
+        : IBinaryOperation_Tensor_Scalar<T, T>,
+          IBinaryOperation_Tensor_Tensor<T, T>
+        where T : INumber<T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.CopySign(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.CopySign(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.CopySign(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.CopySign(x, y, destination);
+            }
+        }
+
+        public readonly struct Cos<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Cos(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Cos(x, destination);
+            }
+        }
+
+        public readonly struct Cosh<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IHyperbolicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Cosh(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Cosh(x, destination);
+            }
+        }
+
+        public struct CosineSimilarity<T>
+            : IBinaryOperation_Tensor_Tensor<T, ValueTuple<T, T, T>>
+            where T : IRootFunctions<T>
+        {
+            /// This method effectively computes <c>TensorPrimitives.Dot(x, y) / (<typeparamref name="T"/>.Sqrt(TensorPrimitives.SumOfSquares(x)) * <typeparamref name="T"/>.Sqrt(TensorPrimitives.SumOfSquares(y)).</c>
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref (T, T, T) destination)
+            {
+                destination.Item1 += (x * y);
+                destination.Item2 += (x * x);
+                destination.Item3 += (y * y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<(T, T, T)> destination)
+            {
+                destination[0].Item1 += TensorPrimitives.Dot(x, y);
+                destination[0].Item2 += TensorPrimitives.SumOfSquares(x);
+                destination[0].Item3 += TensorPrimitives.SumOfSquares(y);
+            }
+        }
+
+        public readonly struct CosPi<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.CosPi(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.CosPi(x, destination);
+            }
+        }
+
+        public readonly struct DegreesToRadians<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.DegreesToRadians(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.DegreesToRadians(x, destination);
+            }
+        }
+
+        public readonly struct Divide<T>
+            : IBinaryOperation_Scalar_Tensor<T, T, T>,
+              IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IDivisionOperators<T, T, T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = x / y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.Divide(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = x / y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Divide(x, y, destination);
+            }
+
+            public static void Invoke(T x, ref readonly T y, ref T destination)
+            {
+                destination = x / y;
+            }
+            public static void Invoke(T x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Divide(x, y, destination);
+            }
+        }
+
+        public struct Dot<T>
+            : IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplicativeIdentity<T, T>, IMultiplyOperators<T, T, T>
+        {
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination += x * y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                destination[0] += TensorPrimitives.Dot(x, y);
+            }
+        }
+
+        public readonly struct Exp<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IExponentialFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Exp(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Exp(x, destination);
+            }
+        }
+
+        public readonly struct Exp10<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IExponentialFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Exp10(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Exp10(x, destination);
+            }
+        }
+
+        public readonly struct Exp10M1<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IExponentialFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Exp10M1(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Exp10M1(x, destination);
+            }
+        }
+
+        public readonly struct Exp2<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IExponentialFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Exp2(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Exp2(x, destination);
+            }
+        }
+
+        public readonly struct Exp2M1<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IExponentialFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Exp2M1(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Exp2M1(x, destination);
+            }
+        }
+
+        public readonly struct ExpM1<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IExponentialFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.ExpM1(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.ExpM1(x, destination);
+            }
+        }
+
+        public readonly struct Floor<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IFloatingPoint<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Floor(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Floor(x, destination);
+            }
+        }
+
+        public readonly struct Hypot<T>
+            : IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IRootFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.Hypot(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Hypot(x, y, destination);
+            }
+        }
+
+        public readonly struct Ieee754Remainder<T>
+            : IBinaryOperation_Scalar_Tensor<T, T, T>,
+              IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IFloatingPointIeee754<T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.Ieee754Remainder(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.Ieee754Remainder(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.Ieee754Remainder(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Ieee754Remainder(x, y, destination);
+            }
+
+            public static void Invoke(T x, ref readonly T y, ref T destination)
+            {
+                destination = T.Ieee754Remainder(x, y);
+            }
+            public static void Invoke(T x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Ieee754Remainder(x, y, destination);
+            }
+        }
+
+        public readonly struct ILogB<T>
+        : IUnaryOperation_Tensor<T, int>
+        where T : IFloatingPointIeee754<T>
+        {
+            public static void Invoke(ref readonly T x, ref int destination)
+            {
+                destination = T.ILogB(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<int> destination)
+            {
+                TensorPrimitives.ILogB(x, destination);
+            }
+        }
+
+        public readonly struct LeadingZeroCount<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IBinaryInteger<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.LeadingZeroCount(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.LeadingZeroCount(x, destination);
+            }
+        }
+
+        public readonly struct Log<T>
+        : IUnaryOperation_Tensor<T, T>,
+          IBinaryOperation_Tensor_Tensor<T, T>,
+          IBinaryOperation_Tensor_Scalar<T, T>
+        where T : ILogarithmicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Log(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Log(x, destination);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.Log(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Log(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.Log(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.Log(x, y, destination);
+            }
+        }
+
+        public readonly struct Log10<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ILogarithmicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Log10(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Log10(x, destination);
+            }
+        }
+
+        public readonly struct Log10P1<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ILogarithmicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Log10P1(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Log10P1(x, destination);
+            }
+        }
+
+        public readonly struct Log2<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ILogarithmicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Log2(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Log2(x, destination);
+            }
+        }
+
+        public readonly struct Log2P1<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ILogarithmicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Log2P1(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Log2P1(x, destination);
+            }
+        }
+
+        public readonly struct LogP1<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ILogarithmicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.LogP1(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.LogP1(x, destination);
+            }
+        }
+
+        public struct Max<T>
+            : IUnaryReduction_Tensor<T, T>,
+              IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : INumber<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Max(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                destination = TensorPrimitives.Max(x);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.Max(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Max(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.Max(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.Max(x, y, destination);
+            }
+        }
+
+        public struct MaxMagnitude<T>
+            : IUnaryReduction_Tensor<T, T>,
+              IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : INumber<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.MaxMagnitude(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                destination = TensorPrimitives.MaxMagnitude(x);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.MaxMagnitude(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.MaxMagnitude(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.MaxMagnitude(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.MaxMagnitude(x, y, destination);
+            }
+        }
+
+        public struct MaxMagnitudeNumber<T>
+            : IUnaryReduction_Tensor<T, T>,
+              IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : INumberBase<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.MaxMagnitudeNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                destination = TensorPrimitives.MaxMagnitudeNumber(x);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.MaxMagnitudeNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.MaxMagnitudeNumber(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.MaxMagnitudeNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.MaxMagnitudeNumber(x, y, destination);
+            }
+        }
+
+        public struct MaxNumber<T>
+            : IUnaryReduction_Tensor<T, T>,
+              IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : INumber<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.MaxNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                destination = TensorPrimitives.MaxNumber(x);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.MaxNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.MaxNumber(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.MaxNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.MaxNumber(x, y, destination);
+            }
+        }
+
+        public struct Min<T>
+        : IUnaryReduction_Tensor<T, T>,
+          IBinaryOperation_Tensor_Scalar<T, T>,
+          IBinaryOperation_Tensor_Tensor<T, T>
+        where T : INumber<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Min(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                destination = TensorPrimitives.Min(x);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.Min(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Min(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.Min(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.Min(x, y, destination);
+            }
+        }
+
+        public struct MinMagnitude<T>
+            : IUnaryReduction_Tensor<T, T>,
+              IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : INumber<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.MinMagnitude(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                destination = TensorPrimitives.MinMagnitude(x);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.MinMagnitude(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.MinMagnitude(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.MinMagnitude(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.MinMagnitude(x, y, destination);
+            }
+        }
+
+        public struct MinMagnitudeNumber<T>
+            : IUnaryReduction_Tensor<T, T>,
+              IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : INumberBase<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.MinMagnitudeNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                destination = TensorPrimitives.MinMagnitudeNumber(x);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.MinMagnitudeNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.MinMagnitudeNumber(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.MinMagnitudeNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.MinMagnitudeNumber(x, y, destination);
+            }
+        }
+
+        public struct MinNumber<T>
+            : IUnaryReduction_Tensor<T, T>,
+              IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : INumber<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.MinNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                destination = TensorPrimitives.MinNumber(x);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.MinNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.MinNumber(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.MinNumber(x, destination);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.MinNumber(x, y, destination);
+            }
+        }
+
+        public readonly struct Multiply<T>
+            : IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = x * y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.Multiply(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = x * y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Multiply(x, y, destination);
+            }
+        }
+
+        public readonly struct Negate<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IUnaryNegationOperators<T, T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = -x;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Negate(x, destination);
+            }
+        }
+
+        public readonly struct OnesComplement<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IBitwiseOperators<T, T, T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = ~x;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.OnesComplement(x, destination);
+            }
+        }
+
+        public readonly struct PopCount<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IBinaryInteger<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.PopCount(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.PopCount(x, destination);
+            }
+        }
+
+        public readonly struct Pow<T>
+            : IBinaryOperation_Scalar_Tensor<T, T, T>,
+              IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IPowerFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.Pow(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.Pow(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = T.Pow(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Pow(x, y, destination);
+            }
+
+            public static void Invoke(T x, ref readonly T y, ref T destination)
+            {
+                destination = T.Pow(x, y);
+            }
+
+            public static void Invoke(T x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Pow(x, y, destination);
+            }
+        }
+
+        public struct Product<T>
+            : IUnaryReduction_Tensor<T, T>
+            where T : IMultiplicativeIdentity<T, T>, IMultiplyOperators<T, T, T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination *= x;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                destination = TensorPrimitives.Product(x);
+            }
+        }
+
+        public readonly struct RadiansToDegrees<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.RadiansToDegrees(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.RadiansToDegrees(x, destination);
+            }
+        }
+
+        public readonly struct Reciprocal<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IFloatingPoint<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.One / x;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Reciprocal(x, destination);
+            }
+        }
+
+        public readonly struct RootN<T>
+        : IBinaryOperation_Tensor_Int32<T, T>
+        where T : IRootFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, int y, ref T destination)
+            {
+                destination = T.RootN(x, y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, int y, Span<T> destination)
+            {
+                TensorPrimitives.RootN(x, y, destination);
+            }
+        }
+
+        public readonly struct RotateLeft<T>
+        : IBinaryOperation_Tensor_Int32<T, T>
+        where T : IBinaryInteger<T>
+        {
+            public static void Invoke(ref readonly T x, int y, ref T destination)
+            {
+                destination = T.RotateLeft(x, y);
+            }
+            public static void Invoke(ReadOnlySpan<T> x, int y, Span<T> destination)
+            {
+                TensorPrimitives.RotateLeft(x, y, destination);
+            }
+        }
+
+        public readonly struct RotateRight<T>
+        : IBinaryOperation_Tensor_Int32<T, T>
+        where T : IBinaryInteger<T>
+        {
+            public static void Invoke(ref readonly T x, int y, ref T destination)
+            {
+                destination = T.RotateRight(x, y);
+            }
+            public static void Invoke(ReadOnlySpan<T> x, int y, Span<T> destination)
+            {
+                TensorPrimitives.RotateRight(x, y, destination);
+            }
+        }
+
+        public readonly struct Round<T>
+        : IUnaryOperation_Tensor<T, T>,
+          IBinaryOperation_Tensor_Scalar<T, Tuple<int, MidpointRounding>, T>
+        where T : IFloatingPoint<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Round(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Round(x, destination);
+            }
+
+            public static void Invoke(ref readonly T x, Tuple<int, MidpointRounding> y, ref T destination)
+            {
+                destination = T.Round(x, y.Item1, y.Item2);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Tuple<int, MidpointRounding> y, Span<T> destination)
+            {
+                TensorPrimitives.Round(x, y.Item1, y.Item2, destination);
+            }
+        }
+
+        public readonly struct Sigmoid<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IExponentialFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.One / (T.One + T.Exp(-x));
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Sigmoid(x, destination);
+            }
+        }
+
+        public readonly struct Sin<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Sin(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Sin(x, destination);
+            }
+        }
+
+        public readonly struct Sinh<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IHyperbolicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Sinh(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Sinh(x, destination);
+            }
+        }
+
+        public readonly struct SinPi<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.SinPi(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.SinPi(x, destination);
+            }
+        }
+
+        // SoftMax Helper
+        public readonly struct SumExp<T>
+        : IUnaryReduction_Tensor<T, T>
+        where T : IExponentialFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination += T.Exp(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                for (int i = 0; i < x.Length; i++)
+                {
+                    destination += T.Exp(x[i]);
+                }
+            }
+        }
+
+        public readonly struct SoftMax<T>
+        : IBinaryOperation_Tensor_Scalar<T, T>
+        where T : IExponentialFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = T.Exp(x) / y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                for (int i = 0; i < x.Length; i++)
+                {
+                    destination[i] = T.Exp(x[i]) / y;
+                }
+            }
+        }
+
+        public readonly struct Sqrt<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IRootFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Sqrt(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Sqrt(x, destination);
+            }
+        }
+
+        public readonly struct Subtract<T>
+            : IBinaryOperation_Scalar_Tensor<T, T, T>,
+              IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : ISubtractionOperators<T, T, T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = x - y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.Subtract(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = x - y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Subtract(x, y, destination);
+            }
+
+            public static void Invoke(T x, ref readonly T y, ref T destination)
+            {
+                destination = x - y;
+            }
+
+            public static void Invoke(T x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Subtract(x, y, destination);
+            }
+        }
+
+        public struct Sum<T>
+            : IUnaryReduction_Tensor<T, T>
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination += x;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                destination += TensorPrimitives.Sum(x);
+            }
+        }
+
+        public struct SumOfSquaredDifferences<T>
+            : IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T>, ISubtractionOperators<T, T, T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination += (x - y) * (x - y);
+            }
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                for (int i = 0; i < x.Length; i++)
+                {
+                    destination[i] = (x[i] - y) * (x[i] - y);
+                }
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination += (x - y) * (x - y);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                for (int i = 0; i < x.Length; i++)
+                {
+                    destination[i] = (x[i] - y[i]) * (x[i] - y[i]);
+                }
+            }
+        }
+
+        public readonly struct SumOfSquares<T>
+        : IUnaryReduction_Tensor<T, T>
+        where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IMultiplyOperators<T, T, T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination += x * x;
+            }
+            public static void Invoke(ReadOnlySpan<T> x, ref T destination)
+            {
+                destination += TensorPrimitives.SumOfSquares(x);
+            }
+        }
+
+        public readonly struct Tan<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Tan(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Tan(x, destination);
+            }
+        }
+
+        public readonly struct Tanh<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IHyperbolicFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Tanh(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Tanh(x, destination);
+            }
+        }
+
+        public readonly struct TanPi<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : ITrigonometricFunctions<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.TanPi(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.TanPi(x, destination);
+            }
+        }
+
+        public readonly struct TrailingZeroCount<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IBinaryInteger<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.TrailingZeroCount(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.TrailingZeroCount(x, destination);
+            }
+        }
+
+        public readonly struct Truncate<T>
+        : IUnaryOperation_Tensor<T, T>
+        where T : IFloatingPoint<T>
+        {
+            public static void Invoke(ref readonly T x, ref T destination)
+            {
+                destination = T.Truncate(x);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, Span<T> destination)
+            {
+                TensorPrimitives.Truncate(x, destination);
+            }
+        }
+
+        public readonly struct Xor<T>
+            : IBinaryOperation_Tensor_Scalar<T, T>,
+              IBinaryOperation_Tensor_Tensor<T, T>
+            where T : IBitwiseOperators<T, T, T>
+        {
+            public static void Invoke(ref readonly T x, T y, ref T destination)
+            {
+                destination = x ^ y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, T y, Span<T> destination)
+            {
+                TensorPrimitives.Xor(x, y, destination);
+            }
+
+            public static void Invoke(ref readonly T x, ref readonly T y, ref T destination)
+            {
+                destination = x ^ y;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<T> destination)
+            {
+                TensorPrimitives.Xor(x, y, destination);
+            }
+        }
+
+        #endregion
+
+        public readonly struct Fill<T>
+            : IUnaryOperation_Scalar<T, T>
+        {
+            public static void Invoke(ref T destination, T value)
+            {
+                destination = value;
+            }
+
+            public static void Invoke(Span<T> destination, T value)
+            {
+                destination.Fill(value);
+            }
+        }
+
+        public readonly struct GreaterThan<T>
+            : IBinaryOperation_Tensor_Scalar<T, bool>,
+              IBinaryOperation_Tensor_Tensor<T, bool>
+            where T : IComparisonOperators<T, T, bool>
+        {
+            public static void Invoke(ref readonly T left, T right, ref bool destination)
+            {
+                destination = (left > right);
+            }
+
+            public static void Invoke(ref readonly T left, ref readonly T right, ref bool destination)
+            {
+                destination = (left > right);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, T right, Span<bool> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = (left[i] > right);
+                }
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, ReadOnlySpan<T> right, Span<bool> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = (left[i] > right[i]);
+                }
+            }
+        }
+
+        public readonly struct GreaterThanAny<T>
+            : IBinaryOperation_Tensor_Scalar<T, bool>,
+              IBinaryOperation_Tensor_Tensor<T, bool>
+            where T : IComparisonOperators<T, T, bool>
+        {
+            // The main loop early exits at the first false condition, so we
+            // check !(x > y) and returns false on first not greater. The consumer will
+            // then negate whatever the main loop returns as `true` means none
+            // are greater.
+
+            public static void Invoke(ref readonly T left, T right, ref bool destination)
+            {
+                destination = !(left > right);
+            }
+
+            public static void Invoke(ref readonly T left, ref readonly T right, ref bool destination)
+            {
+                destination = !(left > right);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, T right, Span<bool> destination)
+            {
+                Debug.Assert(destination.Length == 1);
+                bool result = false;
+
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    result = !(left[i] > right);
+
+                    if (!result)
+                    {
+                        break;
+                    }
+                }
+
+                destination[0] = result;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, ReadOnlySpan<T> right, Span<bool> destination)
+            {
+                Debug.Assert(destination.Length == 1);
+                bool result = false;
+
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    result = !(left[i] > right[i]);
+
+                    if (!result)
+                    {
+                        break;
+                    }
+                }
+
+                destination[0] = result;
+            }
+        }
+
+        public readonly struct GreaterThanOrEqual<T>
+            : IBinaryOperation_Tensor_Scalar<T, bool>,
+              IBinaryOperation_Tensor_Tensor<T, bool>
+            where T : IComparisonOperators<T, T, bool>
+        {
+            public static void Invoke(ref readonly T left, T right, ref bool destination)
+            {
+                destination = (left >= right);
+            }
+
+            public static void Invoke(ref readonly T left, ref readonly T right, ref bool destination)
+            {
+                destination = (left >= right);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, T right, Span<bool> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = (left[i] >= right);
+                }
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, ReadOnlySpan<T> right, Span<bool> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = (left[i] >= right[i]);
+                }
+            }
+        }
+
+        public readonly struct GreaterThanOrEqualAny<T>
+            : IBinaryOperation_Tensor_Scalar<T, bool>,
+              IBinaryOperation_Tensor_Tensor<T, bool>
+            where T : IComparisonOperators<T, T, bool>
+        {
+            // The main loop early exits at the first false condition, so we
+            // check !(x >= y) and returns false on first not greater or equal.
+            // The consumer will then negate whatever the main loop returns as
+            // `true` means none are greater or equal.
+
+            public static void Invoke(ref readonly T left, T right, ref bool destination)
+            {
+                destination = !(left >= right);
+            }
+
+            public static void Invoke(ref readonly T left, ref readonly T right, ref bool destination)
+            {
+                destination = !(left >= right);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, T right, Span<bool> destination)
+            {
+                Debug.Assert(destination.Length == 1);
+                bool result = false;
+
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    result = !(left[i] >= right);
+
+                    if (!result)
+                    {
+                        break;
+                    }
+                }
+
+                destination[0] = result;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, ReadOnlySpan<T> right, Span<bool> destination)
+            {
+                Debug.Assert(destination.Length == 1);
+                bool result = false;
+
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    result = !(left[i] >= right[i]);
+
+                    if (!result)
+                    {
+                        break;
+                    }
+                }
+
+                destination[0] = result;
+            }
+        }
+
+        public readonly struct LessThan<T>
+            : IBinaryOperation_Tensor_Scalar<T, bool>,
+              IBinaryOperation_Tensor_Tensor<T, bool>
+            where T : IComparisonOperators<T, T, bool>
+        {
+            public static void Invoke(ref readonly T left, T right, ref bool destination)
+            {
+                destination = (left < right);
+            }
+
+            public static void Invoke(ref readonly T left, ref readonly T right, ref bool destination)
+            {
+                destination = (left < right);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, T right, Span<bool> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = (left[i] < right);
+                }
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, ReadOnlySpan<T> right, Span<bool> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = (left[i] < right[i]);
+                }
+            }
+        }
+
+        public readonly struct LessThanAny<T>
+            : IBinaryOperation_Tensor_Scalar<T, bool>,
+              IBinaryOperation_Tensor_Tensor<T, bool>
+            where T : IComparisonOperators<T, T, bool>
+        {
+            // The main loop early exits at the first false condition, so we
+            // check !(x < y) and returns false on first not lesser. The consumer will
+            // then negate whatever the main loop returns as `true` means none
+            // are lesser.
+
+            public static void Invoke(ref readonly T left, T right, ref bool destination)
+            {
+                destination = !(left < right);
+            }
+
+            public static void Invoke(ref readonly T left, ref readonly T right, ref bool destination)
+            {
+                destination = !(left < right);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, T right, Span<bool> destination)
+            {
+                Debug.Assert(destination.Length == 1);
+                bool result = false;
+
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    result = !(left[i] < right);
+
+                    if (!result)
+                    {
+                        break;
+                    }
+                }
+
+                destination[0] = result;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, ReadOnlySpan<T> right, Span<bool> destination)
+            {
+                Debug.Assert(destination.Length == 1);
+                bool result = false;
+
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    result = !(left[i] < right[i]);
+
+                    if (!result)
+                    {
+                        break;
+                    }
+                }
+
+                destination[0] = result;
+            }
+        }
+
+        public readonly struct LessThanOrEqual<T>
+            : IBinaryOperation_Tensor_Scalar<T, bool>,
+              IBinaryOperation_Tensor_Tensor<T, bool>
+            where T : IComparisonOperators<T, T, bool>
+        {
+            public static void Invoke(ref readonly T left, T right, ref bool destination)
+            {
+                destination = (left <= right);
+            }
+
+            public static void Invoke(ref readonly T left, ref readonly T right, ref bool destination)
+            {
+                destination = (left <= right);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, T right, Span<bool> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = (left[i] <= right);
+                }
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, ReadOnlySpan<T> right, Span<bool> destination)
+            {
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    destination[i] = (left[i] <= right[i]);
+                }
+            }
+        }
+
+        public readonly struct LessThanOrEqualAny<T>
+            : IBinaryOperation_Tensor_Scalar<T, bool>,
+              IBinaryOperation_Tensor_Tensor<T, bool>
+            where T : IComparisonOperators<T, T, bool>
+        {
+            // The main loop early exits at the first false condition, so we
+            // check !(x <= y) and returns false on first not lesser or equal.
+            // The consumer will then negate whatever the main loop returns as
+            // `true` means none are lesser or equal.
+
+            public static void Invoke(ref readonly T left, T right, ref bool destination)
+            {
+                destination = !(left <= right);
+            }
+
+            public static void Invoke(ref readonly T left, ref readonly T right, ref bool destination)
+            {
+                destination = !(left <= right);
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, T right, Span<bool> destination)
+            {
+                Debug.Assert(destination.Length == 1);
+                bool result = false;
+
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    result = !(left[i] <= right);
+
+                    if (!result)
+                    {
+                        break;
+                    }
+                }
+
+                destination[0] = result;
+            }
+
+            public static void Invoke(ReadOnlySpan<T> left, ReadOnlySpan<T> right, Span<bool> destination)
+            {
+                Debug.Assert(destination.Length == 1);
+                bool result = false;
+
+                for (int i = 0; i < destination.Length; i++)
+                {
+                    result = !(left[i] <= right[i]);
+
+                    if (!result)
+                    {
+                        break;
+                    }
+                }
+
+                destination[0] = result;
+            }
+        }
+
+        public interface IBinaryOperation_Tensor_Scalar<T, TResult>
+            : IBinaryOperation_Tensor_Scalar<T, T, TResult>
+        {
+        }
+
+        public interface IBinaryOperation_Tensor_Int32<T, TResult>
+            : IBinaryOperation_Tensor_Scalar<T, int, TResult>
+        {
+        }
+
+        public interface IBinaryOperation_Tensor_Scalar<T1, T2, TResult>
+        {
+            static abstract void Invoke(ref readonly T1 x, T2 y, ref TResult destination);
+            static abstract void Invoke(ReadOnlySpan<T1> x, T2 y, Span<TResult> destination);
+        }
+
+        public interface IBinaryOperation_Scalar_Tensor<T1, T2, TResult>
+        {
+            static abstract void Invoke(T1 x, ref readonly T2 y, ref TResult destination);
+            static abstract void Invoke(T1 x, ReadOnlySpan<T2> y, Span<TResult> destination);
+        }
+
+        public interface IBinaryOperation_Tensor_Tensor<T, TResult>
+        {
+            static abstract void Invoke(ref readonly T x, ref readonly T y, ref TResult destination);
+            static abstract void Invoke(ReadOnlySpan<T> x, ReadOnlySpan<T> y, Span<TResult> destination);
+        }
+
+        public interface IOperation<T>
+        {
+            static abstract void Invoke(ref T destination);
+            static abstract void Invoke(Span<T> destination);
+        }
+
+        public interface IUnaryOperation_Scalar<T, TResult>
+        {
+            static abstract void Invoke(ref TResult destination, T x);
+            static abstract void Invoke(Span<TResult> destination, T x);
+        }
+
+        public interface IUnaryOperation_Tensor<T, TResult>
+        {
+            static abstract void Invoke(ref readonly T x, ref TResult destination);
+            static abstract void Invoke(ReadOnlySpan<T> x, Span<TResult> destination);
+        }
+
+        public interface IUnaryReduction_Tensor<T, TResult>
+        {
+            static abstract void Invoke(ref readonly T x, ref TResult destination);
+            static abstract void Invoke(ReadOnlySpan<T> x, ref TResult destination);
+        }
+
+        internal readonly struct RentedBuffer
+        {
+            public static Span<T> Create<T>(int rank, ReadOnlySpan<nint> strides, out nint linearOffset, [UnscopedRef] out RentedBuffer<T> rentedBuffer)
+                where T : INumber<T>
+            {
+                Span<T> output = RentedBuffer<T>.Create(rank, out rentedBuffer);
+                linearOffset = 0 - (!strides.IsEmpty ? strides[^1] : 0);
+
+                output[^1] = T.CreateChecked(-1);
+                return output;
+            }
+
+            public static Span<T> CreateUninitialized<T>(int rank, [UnscopedRef] out RentedBuffer<T> rentedBuffer)
+                => RentedBuffer<T>.Create(rank, out rentedBuffer);
+        }
+
+        internal ref struct RentedBuffer<T> : IDisposable
+        {
+            private T[]? _array;
+            private TensorShape.InlineBuffer<T> _inline;
+
+            public static Span<T> Create(int rank, [UnscopedRef] out RentedBuffer<T> rentedBuffer)
+            {
+                if (rank > TensorShape.MaxInlineRank)
+                {
+                    rentedBuffer._array = ArrayPool<T>.Shared.Rent(rank);
+                    Unsafe.SkipInit(out rentedBuffer._inline);
+
+                    Span<T> resultBuffer = rentedBuffer._array.AsSpan(0, rank);
+                    resultBuffer.Clear();
+                    return resultBuffer;
+                }
+                else
+                {
+                    rentedBuffer._array = null;
+                    rentedBuffer._inline = default;
+
+                    return ((Span<T>)rentedBuffer._inline)[..rank];
+                }
+            }
+
+            public void Dispose()
+            {
+                if (_array is not null)
+                {
+                    ArrayPool<T>.Shared.Return(_array);
+                    _array = null;
+                }
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorShape.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorShape.cs
index 5aa155efff6a46..9cf04855e93d5d 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorShape.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorShape.cs
@@ -1,66 +1,1261 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Buffers;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using Microsoft.VisualBasic;
 
 namespace System.Numerics.Tensors
 {
+    // TensorShape tracks the core information required to safely interact with memory
+    // for tensors and tensor spans alike.
+    //
+    // We avoid allocating for small ranks up to MaxInlineRank in size and allocate a
+    // single buffer for larger ranks. This buffer will always be precisely `InlineBufferCount * rank`
+    // in size where the first rank elements are the length, the next rank elements are
+    // the strides, and then the next rank elements are the rank order.
+    //
+    // We cache both a flattened length and a linear length to avoid recalculating these
+    // key properties. The flattened length is the total number of elements represented
+    // by the tensor, however due to implicit broadcasting this may be greater than the
+    // amount of memory that actually backs the tensor. While the linear length is the
+    // backing storage size that is present. We can also have arbitrary strides, such as
+    // lengths: [4], strides: [2]. In this case the flattenedLength = 4, while the
+    // linearLength: 8. We can also have a slice of a tensor, such as lengths: [2, 2],
+    // strides: [3, 1] (which could have been taken from a 3x3 contiguous and dense tensor).
+    //
+    // These invariants allow us to safely and efficiently index into the backing storage
+    // as we know that memory functionally wraps around after linearLength elements. It
+    // also means that we only support broadcasting to greater dimensions and thus lengths
+    // strides and the backing memory form a strict relationship that is validated by the
+    // public constructors.
+
+    [Flags]
+    internal enum TensorFlags : uint
+    {
+        None = 0,
+        IsContiguousAndDense = (1 << 0),
+        IsBroadcast = (1 << 1),
+    }
 
     [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
-    internal readonly struct TensorShape
+    internal readonly struct TensorShape : IEquatable<TensorShape>
     {
-        // Used to determine when we need to allocate a metadata array
-        public const int MaxInlineArraySize = 5;
+        // The layout of the fields here is very particular and is intentionally designed to
+        // be compact and cache-friendly. The current size on a 64-bit system is 108+4 bytes
+        // and this fits within 2 cache lines, where 64 bytes is the typical cache line size.
+        //
+        // The TensorSpan and ReadOnlyTensorSpan types then track a byref field which takes
+        // an additional 8 bytes. This leaves 8 bytes still available for use for other scenarios
+        // if required.
+
+        internal const int MaxInlineRank = 4;
+        private const int InlineBufferCount = 3;
+
+        private readonly nint[]? _metadata;                         // 8 bytes
+
+        private readonly nint _flattenedLength;                     // 8 bytes
+        private readonly nint _linearLength;                        // 8 bytes
+
+        private readonly InlineBuffer<nint> _inlineLengths;         // 4x8 bytes (32)
+        private readonly InlineBuffer<nint> _inlineStrides;         // 4x8 bytes (32)
+        private readonly InlineBuffer<int>  _inlineLinearRankOrder; // 4x4 bytes (16)
+
+        private readonly int _rank;
+        private readonly TensorFlags _flags;                  // 4 bytes
+
+        private TensorShape(nint linearLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, scoped ReadOnlySpan<int> linearRankOrder)
+        {
+            int rank = lengths.Length;
+
+            if (rank == 0)
+            {
+                lengths = [0];
+                rank = 1;
+            }
+            Debug.Assert(rank >= 1);
+
+            scoped Span<nint> destinationLengths;
+            scoped Span<nint> destinationStrides;
+            scoped Span<int> destinationLinearRankOrder;
+
+            if (rank > MaxInlineRank)
+            {
+                nint[] metadata = new nint[rank * InlineBufferCount];
+
+                destinationLengths = metadata.AsSpan(rank * 0, rank);
+                destinationStrides = metadata.AsSpan(rank * 1, rank);
+                destinationLinearRankOrder = MemoryMarshal.CreateSpan(
+                    ref Unsafe.As<nint, int>(ref metadata[rank * 2]),
+                    rank
+                );
+
+                _metadata = metadata;
+            }
+            else
+            {
+                destinationLengths = ((Span<nint>)_inlineLengths)[..rank];
+                destinationStrides = ((Span<nint>)_inlineStrides)[..rank];
+                destinationLinearRankOrder = ((Span<int>)_inlineLinearRankOrder)[..rank];
+            }
+
+            if (linearRankOrder.Length == 0)
+            {
+                // The linearRankOrder is expected to be in "row-major" order, that is otherwise
+                // known as "big-endian" order where the dimensions that are farthest apart
+                // (i.e. have the greatest impact to computing a linear index) appear first.
+                //
+                // So, when no rank order is specified by the user we simply populate this
+                // as 0 to rank-1. In the case strides is also not specified, this will be
+                // correct "as is"; otherwise, we will sort this based on which stride is
+                // largest prior to validating the user provided strides.
+
+                for (int i = 0; i < destinationLinearRankOrder.Length; i++)
+                {
+                    destinationLinearRankOrder[i] = i;
+                }
+            }
+            else if (linearRankOrder.Length != rank)
+            {
+                ThrowHelper.ThrowArgument_InvalidTensorShape();
+            }
+            else
+            {
+                // If a rank order was specified, then we need to ensure that it is valid,
+                // which should mean that when sorting we have values from 0 to rank-1.
+                //
+                // While this does copy the rank order twice, the typical rank is expected
+                // to be small and so the cost should be minimal.
+
+                linearRankOrder.CopyTo(destinationLinearRankOrder);
+                destinationLinearRankOrder.Sort();
+
+                for (int i = 0; i < linearRankOrder.Length; i++)
+                {
+                    if (destinationLinearRankOrder[i] != i)
+                    {
+                        ThrowHelper.ThrowArgument_InvalidTensorShape();
+                    }
+                }
+
+                linearRankOrder.CopyTo(destinationLinearRankOrder);
+            }
+
+            nint flattenedLength = 1;
+            nint maximumLinearIndex = 0;
+
+            if (strides.Length == 0)
+            {
+                // When no strides are specified, we need to computing them based on the given
+                // rank order. We use destinationLinearRankOrder here to ensure that we have a
+                // correct order even if no rank order was specified by the user.
+                //
+                // To do this, we simply iterate the rank order from least to most significant
+                // so that the strides match the expected order, being the product of all previous
+                // dimension lengths.
+
+                for (int i = 0; i < destinationLinearRankOrder.Length; i++)
+                {
+                    int rankIndex = destinationLinearRankOrder.Length - (i + 1);
+                    int linearRankIndex = destinationLinearRankOrder[rankIndex];
+
+                    nint length = lengths[linearRankIndex];
+
+                    if (length < 0)
+                    {
+                        ThrowHelper.ThrowArgument_LengthIsNegative();
+                    }
+
+                    nint stride = flattenedLength;
+
+                    if (length > 1)
+                    {
+                        maximumLinearIndex = checked(maximumLinearIndex + ((length - 1) * stride));
+                    }
+                    else
+                    {
+                        stride = 0;
+                        _flags |= TensorFlags.IsBroadcast;
+                    }
+
+                    destinationLengths[linearRankIndex] = length;
+                    destinationStrides[linearRankIndex] = stride;
+
+                    flattenedLength = checked(flattenedLength * length);
+                }
+            }
+            else if (strides.Length != lengths.Length)
+            {
+                ThrowHelper.ThrowArgument_InvalidTensorShape();
+            }
+            else
+            {
+                // If a strides was specified, then we need to ensure it is valid as well,
+                // which should mean that when sorted by rank order (most to least significant)
+                // each stride should be greater than or equal to the previous stride multiplied
+                // by the dimension length.
+                //
+                // The reason it is "or equal" and not simply "greater than" is because a dimension
+                // can be length 1 and thus the stride is the same as the previous rank.
+                //
+                // Additionally, when sorted we allow for the first n (most significant) strides to be
+                // specified as 0 in which case we automatically compute that to be the same as stride
+                // n+1. This makes it convenient to support implicit broadcasting where higher dimensions
+                // aren't actually stored in memory.
+
+                nint minimumNonZeroStride = 0;
+                var sortedWithIndex = destinationLinearRankOrder.ToArray()
+                    .Select((value, index) => new { Value = value, Index = index })
+                    .OrderBy(x => x.Value)
+                    .ToArray();
+
+                int[] sortedOrder = sortedWithIndex.Select(x => x.Index).ToArray();
+                for (int i = 0; i < destinationLinearRankOrder.Length; i++)
+                {
+                    int rankIndex = destinationLinearRankOrder.Length - (i + 1);
+                    int linearRankIndex = sortedOrder[rankIndex];
 
-        // Used to determine when we can stack alloc for indexing vs when we need to allocate
-        public const int MaxInlineRank = 8;
+                    nint length = lengths[linearRankIndex];
 
-        internal readonly nint[]? _metadata;      // 8 bytes
+                    if (length < 0)
+                    {
+                        ThrowHelper.ThrowArgument_LengthIsNegative();
+                    }
 
-        internal readonly nint _memoryLength;   // 8 bytes
-        internal readonly int _rank;              // 4 bytes
+                    nint stride = strides[linearRankIndex];
 
-        private readonly NintBuffer _lengths;
-        private readonly NintBuffer _strides;
+                    if (stride < 0)
+                    {
+                        ThrowHelper.ThrowArgument_StrideIsNegative();
+                    }
 
-        internal TensorShape(nint memoryLength, ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides)
+                    if (stride != 0)
+                    {
+                        if (stride < minimumNonZeroStride)
+                        {
+                            // The next stride needs to be at least as big as the
+                            // previous stride times the dimension length, otherwise
+                            // the linear rank ordering is incorrect
+                            ThrowHelper.ThrowArgument_InvalidTensorShape();
+                        }
+
+                        if (length <= 1)
+                        {
+                            // We require the stride to be zero if the dimension length
+                            // is 0 or 1, as this is necessary for indexing with broadcast to
+                            // work as expected.
+                            ThrowHelper.ThrowArgument_InvalidTensorShape();
+                        }
+
+                        minimumNonZeroStride = checked(length * stride);
+                        maximumLinearIndex = checked(maximumLinearIndex + (minimumNonZeroStride - stride));
+                    }
+                    else
+                    {
+                        _flags |= TensorFlags.IsBroadcast;
+                    }
+
+                    destinationLengths[linearRankIndex] = length;
+                    destinationStrides[linearRankIndex] = stride;
+
+                    flattenedLength = checked(flattenedLength * length);
+                }
+            }
+
+            // Once we've finished computing everything physically present in the input
+            // we need to ensure that the linearLength is greater than or equal to the
+            // minimumLinearLength so that lengths is in range of the backing buffer and
+            // so that we can support broadcasting for anything that was length 1.
+
+            nint minimumLinearLength = (flattenedLength != 0) ? (maximumLinearIndex + 1) : 0;
+
+            if (linearLength != -1)
+            {
+                ArgumentOutOfRangeException.ThrowIfLessThan(linearLength, minimumLinearLength);
+            }
+
+            _flattenedLength = flattenedLength;
+            _linearLength = minimumLinearLength;
+
+            _rank = rank;
+
+            if (flattenedLength == minimumLinearLength)
+            {
+                // When the flattenedLength and minimumLinearLength are the same, then the
+                // underlying buffer is "contiguous and dense" which allows various other
+                // optimizations to be utilized when processing the tensor.
+                _flags |= TensorFlags.IsContiguousAndDense;
+            }
+
+            ValidateState();
+        }
+
+        private TensorShape(nint flattenedLength, nint linearLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, scoped ReadOnlySpan<int> linearRankOrder, int rank, TensorFlags flags)
         {
-            _memoryLength = memoryLength;
-            _rank = lengths.Length;
-            if (lengths.Length > MaxInlineArraySize)
+            Debug.Assert(lengths.Length == rank);
+            Debug.Assert(strides.Length == rank);
+            Debug.Assert(linearRankOrder.Length == rank);
+
+            scoped Span<nint> destinationLengths;
+            scoped Span<nint> destinationStrides;
+            scoped Span<int> destinationLinearRankOrder;
+
+            if (rank > MaxInlineRank)
             {
-                _metadata = new nint[lengths.Length + strides.Length];
-                lengths.CopyTo(MemoryMarshal.CreateSpan(ref _metadata[0], lengths.Length));
-                strides.CopyTo(MemoryMarshal.CreateSpan(ref _metadata[lengths.Length], strides.Length));
+                nint[] metadata = new nint[rank * InlineBufferCount];
+
+                destinationLengths = metadata.AsSpan(rank * 0, rank);
+                destinationStrides = metadata.AsSpan(rank * 1, rank);
+                destinationLinearRankOrder = MemoryMarshal.CreateSpan(
+                    ref Unsafe.As<nint, int>(ref metadata[rank * 2]),
+                    rank
+                );
+
+                _metadata = metadata;
             }
             else
             {
-                lengths.CopyTo(_lengths);
-                strides.CopyTo(_strides);
+                destinationLengths = ((Span<nint>)_inlineLengths)[..rank];
+                destinationStrides = ((Span<nint>)_inlineStrides)[..rank];
+                destinationLinearRankOrder = ((Span<int>)_inlineLinearRankOrder)[..rank];
             }
+
+            _flattenedLength = flattenedLength;
+            _linearLength = linearLength;
+
+            lengths.CopyTo(destinationLengths);
+            strides.CopyTo(destinationStrides);
+            linearRankOrder.CopyTo(destinationLinearRankOrder);
+
+            _rank = rank;
+            _flags = flags;
+
+            ValidateState();
         }
 
-        [InlineArray(MaxInlineArraySize)] // 5x8 bytes (40)
-        private struct NintBuffer
+        public bool IsBroadcast => (_flags & TensorFlags.IsBroadcast) != 0;
+
+        public bool IsContiguousAndDense => (_flags & TensorFlags.IsContiguousAndDense) != 0;
+
+        public nint FlattenedLength => _flattenedLength;
+
+        public bool IsEmpty => _flattenedLength == 0;
+
+        public nint LinearLength => _linearLength;
+
+        [UnscopedRef]
+        public ReadOnlySpan<nint> Lengths
         {
-            public nint e0;
+            get
+            {
+                if (_metadata is not nint[] metadata)
+                {
+                    return ((ReadOnlySpan<nint>)_inlineLengths)[.._rank];
+                }
+                else
+                {
+                    int rank = metadata.Length / InlineBufferCount;
+                    return metadata.AsSpan(rank * 0, rank);
+                }
+            }
         }
 
         [UnscopedRef]
-        public ReadOnlySpan<nint> Lengths => (_metadata is null)
-                                           ? ((ReadOnlySpan<nint>)_lengths).Slice(0, _rank)
-                                           : MemoryMarshal.CreateReadOnlySpan(ref MemoryMarshal.GetArrayDataReference(_metadata), _rank);
+        public ReadOnlySpan<int> LinearRankOrder
+        {
+            get
+            {
+                if (_metadata is not nint[] metadata)
+                {
+                    return ((ReadOnlySpan<int>)_inlineLinearRankOrder)[.._rank];
+                }
+                else
+                {
+                    int rank = metadata.Length / InlineBufferCount;
+                    return MemoryMarshal.CreateSpan(
+                        ref Unsafe.As<nint, int>(ref metadata[rank * 2]),
+                        rank
+                    );
+                }
+            }
+        }
+
+        public int Rank => _rank;
 
         [UnscopedRef]
-        public ReadOnlySpan<nint> Strides => (_metadata is null)
-                                           ? ((ReadOnlySpan<nint>)_strides).Slice(0, _rank)
-                                           : MemoryMarshal.CreateReadOnlySpan(ref MemoryMarshal.GetArrayDataReference(_metadata), _rank * 2).Slice(_rank);
+        public ReadOnlySpan<nint> Strides
+        {
+            get
+            {
+                if (_metadata is not nint[] metadata)
+                {
+                    return ((ReadOnlySpan<nint>)_inlineStrides)[.._rank];
+                }
+                else
+                {
+                    int rank = metadata.Length / InlineBufferCount;
+                    return metadata.AsSpan(rank * 1, rank);
+                }
+            }
+        }
+
+        public static bool operator ==(in TensorShape left, in TensorShape right)
+        {
+            int rank = left.Rank;
+
+            if (rank != right.Rank)
+            {
+                return false;
+            }
+
+            if (left.FlattenedLength != right.FlattenedLength)
+            {
+                return false;
+            }
 
-        public nint FlattenedLength => TensorSpanHelpers.CalculateTotalLength(Lengths);
+            if (left.LinearLength != right.LinearLength)
+            {
+                return false;
+            }
+
+            ReadOnlySpan<nint> leftLengths = left.Lengths;
+            ReadOnlySpan<int> leftLinearRankOrder = left.LinearRankOrder;
+            ReadOnlySpan<nint> leftStrides = left.Strides;
+
+            ReadOnlySpan<nint> rightLengths = right.Lengths;
+            ReadOnlySpan<int> rightLinearRankOrder = right.LinearRankOrder;
+            ReadOnlySpan<nint> rightStrides = right.Strides;
+
+            for (int i = 0; i < rank; i++)
+            {
+                // We need to compare lengths and strides based on the linearRankOrder
+                // to ensure that two tensors representing the same memory, but where
+                // the shapes are logically, but not physically, transposed are considered
+                // equal.
+
+                int leftRankIndex = leftLinearRankOrder[i];
+                int rightRankIndex = rightLinearRankOrder[i];
+
+                if (leftLengths[leftRankIndex] != rightLengths[rightRankIndex])
+                {
+                    return false;
+                }
+
+                if (leftStrides[leftRankIndex] != rightStrides[rightRankIndex])
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static bool operator !=(in TensorShape left, in TensorShape right) => !(left == right);
+
+        public nint AdjustToNextIndex(in TensorShape destinationShape, nint linearOffset, Span<nint> indexes)
+        {
+            Debug.Assert(indexes.Length >= Rank);
+            Debug.Assert(indexes.Length == destinationShape.Rank);
+
+            ReadOnlySpan<nint> lengths = Lengths;
+            ReadOnlySpan<nint> strides = Strides;
+
+            ReadOnlySpan<nint> destinationLengths = destinationShape.Lengths;
+
+            for (int i = 0; i < strides.Length; i++)
+            {
+                int rankIndex = lengths.Length - (i + 1);
+                int destinationRankIndex = destinationShape.Lengths.Length - (i + 1);
+
+                nint length = lengths[rankIndex];
+                nint stride = strides[rankIndex];
+
+                nint index = ++indexes[destinationRankIndex];
+                linearOffset += stride;
+
+                // We can have a scenario such as lengths: [1], destinationLengths: [2] in
+                // which case we still need to keep incrementing the index but without
+                // adjusting the linearOffset
+
+                if (index < destinationLengths[destinationRankIndex])
+                {
+                    if (index >= length)
+                    {
+                        // We should only be here if we were broadcast
+                        Debug.Assert((length == 1) && (stride == 0));
+                    }
+                    return linearOffset;
+                }
+
+                indexes[destinationRankIndex] = 0;
+                linearOffset -= (stride * length);
+            }
+
+            if (indexes.Length != Rank)
+            {
+                for (int i = strides.Length; i < destinationLengths.Length; i++)
+                {
+                    int rankIndex = destinationLengths.Length - (i + 1);
+
+                    nint length = destinationLengths[rankIndex];
+                    // Strides are always 0 because we are broadcasting at this point in the loop.
+
+                    nint index = ++indexes[rankIndex];
+
+                    if (index < length)
+                    {
+                        // For any indexes that exist in the destinationShape but not
+                        // in the srcShape we will only increment them if all lower
+                        // indexes were 0. This means we're starting over at the beginning
+                        // of the srcShape and the linearOffset must be 0.
+                        break;
+                    }
+
+                    indexes[rankIndex] = 0;
+                }
+            }
+            return 0;
+        }
+
+        public nint AdjustToPreviousIndex(in TensorShape destinationShape, nint linearOffset, Span<nint> indexes)
+        {
+            Debug.Assert(indexes.Length >= Rank);
+            Debug.Assert(indexes.Length == destinationShape.Rank);
+
+            ReadOnlySpan<nint> lengths = Lengths;
+            ReadOnlySpan<nint> strides = Strides;
+
+            ReadOnlySpan<nint> destinationLengths = destinationShape.Lengths;
+
+            for (int i = 0; i < strides.Length; i++)
+            {
+                int rankIndex = lengths.Length - (i + 1);
+                int destinationRankIndex = destinationShape.Lengths.Length - (i + 1);
+
+                nint length = lengths[rankIndex];
+                nint stride = strides[rankIndex];
+
+                nint index = --indexes[destinationRankIndex];
+                linearOffset -= stride;
+
+                // We can have a scenario such as lengths: [1], destinationLengths: [2] in
+                // which case we still need to keep incrementing the index but without
+                // adjusting the linearOffset
+
+                if (index >= 0)//destinationLengths[destinationRankIndex])
+                {
+                    if (index >= length)
+                    {
+                        // We should only be here if we were broadcast
+                        Debug.Assert((length == 1) && (stride == 0));
+                    }
+                    return linearOffset;
+                }
+
+                indexes[destinationRankIndex] = lengths[rankIndex];
+                linearOffset += (stride * length);
+            }
+
+            if (indexes.Length != Rank)
+            {
+                for (int i = destinationLengths.Length - 1; i >= strides.Length; i--)
+                {
+                    int rankIndex = destinationLengths.Length - (i + 1);
+
+                    nint length = destinationLengths[rankIndex];
+                    // Strides are always 0 because we are broadcasting at this point in the loop.
+
+                    nint index = ++indexes[rankIndex];
+
+                    if (index < length)
+                    {
+                        // For any indexes that exist in the destinationShape but not
+                        // in the srcShape we will only increment them if all lower
+                        // indexes were 0. This means we're starting over at the beginning
+                        // of the srcShape and the linearOffset must be 0.
+                        break;
+                    }
+
+                    indexes[rankIndex] = 0;
+                }
+            }
+            return 0;
+        }
+
+        // Answer the question: Can shape2 turn into shape1 or vice-versa if allowBidirectional?
+        public static bool AreCompatible(in TensorShape shape1, in TensorShape shape2, bool allowBidirectional)
+        {
+            int rankDelta = shape1.Rank - shape2.Rank;
+
+            if (rankDelta < 0)
+            {
+                if (!allowBidirectional)
+                {
+                    return false;
+                }
+
+                ref readonly TensorShape tmpShape = ref shape1;
+                shape1 = ref shape2;
+                shape2 = ref tmpShape;
+
+                rankDelta = -rankDelta;
+                Debug.Assert(rankDelta > 0);
+            }
+
+            // We need both to be empty if either is empty
+
+            if (shape1.IsEmpty)
+            {
+                return shape2.IsEmpty;
+            }
+            else if (shape2.IsEmpty)
+            {
+                return false;
+            }
+
+            // We need the lengths to be equal, length2 to be 1, or
+            // length1 to be 1 and be doing a bidirectional check.
+
+            ReadOnlySpan<nint> lengths1 = shape1.Lengths[rankDelta..];
+            ReadOnlySpan<nint> lengths2 = shape2.Lengths;
+
+            for (int i = 0; i < lengths1.Length; i++)
+            {
+                nint length1 = lengths1[i];
+                nint length2 = lengths2[i];
+
+                if (length1 == length2)
+                {
+                    continue;
+                }
+                else if ((length1 == 1) && allowBidirectional)
+                {
+                    continue;
+                }
+                else if (length2 == 1)
+                {
+                    continue;
+                }
+
+                return false;
+            }
+
+            if (!allowBidirectional)
+            {
+                // When we aren't bidirectionally compatible, then we
+                // need to ensure that if stride1 is 0, then stride2
+                // is also zero; otherwise we cannot safely operate.
+
+                ReadOnlySpan<nint> strides1 = shape1.Strides[rankDelta..];
+                ReadOnlySpan<nint> strides2 = shape2.Strides;
+
+                for (int i = 0; i < strides1.Length; i++)
+                {
+                    nint stride1 = strides1[i];
+                    nint stride2 = strides2[i];
 
-        public bool IsEmpty => FlattenedLength == 0;
+                    if ((stride1 == 0) && (stride2 != 0))
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        // Answer the question: Can shape2 turn into shape1Lengths
+        public static bool AreCompatible(in ReadOnlySpan<nint> shape1Lengths, in TensorShape shape2)
+        {
+            int rankDelta = shape1Lengths.Length - shape2.Rank;
+
+            if (rankDelta < 0)
+            {
+                return false;
+            }
+
+            // We need both to be empty if either is empty
+
+            if (shape1Lengths.IsEmpty)
+            {
+                return shape2.IsEmpty;
+            }
+            else if (shape2.IsEmpty)
+            {
+                return false;
+            }
+
+            // We need the lengths to be equal, length2 to be 1, or
+            // length1 to be 1 and be doing a bidirectional check.
+
+            ReadOnlySpan<nint> lengths1 = shape1Lengths[rankDelta..];
+            ReadOnlySpan<nint> lengths2 = shape2.Lengths;
+
+            for (int i = 0; i < lengths1.Length; i++)
+            {
+                nint length1 = lengths1[i];
+                nint length2 = lengths2[i];
+
+                if (length1 == length2)
+                {
+                    continue;
+                }
+                else if (length2 == 1)
+                {
+                    continue;
+                }
+
+                return false;
+            }
+
+            return true;
+        }
+
+        public static bool AreLengthsTheSame(in TensorShape shape1, in TensorShape shape2)
+        {
+            return AreLengthsTheSame(shape1.Lengths, shape2.Lengths);
+        }
+
+        public static bool AreLengthsTheSame(ReadOnlySpan<nint> lengths1, ReadOnlySpan<nint> lengths2)
+        {
+            return lengths1.SequenceEqual(lengths2);
+        }
+
+        public static TensorShape Create(Array? array)
+        {
+            if (array is not null)
+            {
+                nint linearLength = (nint)array.LongLength;
+                int rank = array.Rank;
+
+                nint[]? lengthsArray = null;
+                InlineBuffer<nint> lengthsBuffer;
+                scoped Span<nint> lengths;
+
+                if (rank > MaxInlineRank)
+                {
+                    lengthsArray = ArrayPool<nint>.Shared.Rent(rank);
+                    lengths = lengthsArray.AsSpan(0, rank);
+                }
+                else
+                {
+                    Unsafe.SkipInit(out lengthsBuffer);
+                    lengths = ((Span<nint>)lengthsBuffer)[..rank];
+                }
+
+                for (int i = 0; i < rank; i++)
+                {
+                    lengths[i] = array.GetLength(i);
+                }
+
+                TensorShape result = new TensorShape(
+                    linearLength,
+                    lengths,
+                    strides: [],
+                    linearRankOrder: []
+                );
+
+                if (lengthsArray is not null)
+                {
+                    ArrayPool<nint>.Shared.Return(lengthsArray);
+                }
+                return result;
+            }
+            return default;
+        }
+
+        public static TensorShape Create(Array? array, scoped ReadOnlySpan<int> start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, out nint linearOffset)
+        {
+            nint computedOffset = 0;
+
+            nint[]? intermediateLengthsArray = null;
+            InlineBuffer<nint> intermediateLengthsBuffer;
+            scoped Span<nint> intermediateLengths = default;
+
+            if (array is not null)
+            {
+                int rank = array.Rank;
+
+                if ((start.Length != 0) && (start.Length != rank))
+                {
+                    ThrowHelper.ThrowArgument_StartIndexOutOfBounds();
+                }
+
+                nint linearLength = (nint)array.LongLength;
+
+                if (lengths.Length == 0)
+                {
+                    // When no lengths are specified we need to retrieve them from the array
+                    // since that has the expected shape. We don't need to validate the strides
+                    // however as that will be done by the TensorShape constructor.
+
+                    if (rank > MaxInlineRank)
+                    {
+                        intermediateLengthsArray = ArrayPool<nint>.Shared.Rent(rank);
+                        intermediateLengths = intermediateLengthsArray.AsSpan(0, rank);
+                    }
+                    else
+                    {
+                        Unsafe.SkipInit(out intermediateLengthsBuffer);
+                        intermediateLengths = ((Span<nint>)intermediateLengthsBuffer)[..rank];
+                    }
+
+                    for (int i = 0; i < rank; i++)
+                    {
+                        intermediateLengths[i] = array.GetLength(i);
+                    }
+
+                    lengths = intermediateLengths;
+                }
+
+                if (start.Length != 0)
+                {
+                    // In the case a starting index is specified, we need to compute the linear
+                    // index that is the actual starting position. Additionally, if no lengths
+                    // were specified we want to adjust the lengths computed from the array to
+                    // ensure they remain correct. However, we don't validate or adjust the lengths
+                    // if they were user specified as we expect them to already be correct. This
+                    // is because we allow users to do a "reshape" as part of construction and so
+                    // the lengths and strides can mismatch what the underlying multidimensional
+                    // array may have itself.
+
+                    nint stride = 1;
+
+                    for (int i = 0; i < start.Length; i++)
+                    {
+                        int index = start.Length - (i + 1);
+                        int offset = start[index];
+                        int length = array.GetLength(index);
+
+                        if ((offset < 0) || (offset > length))
+                        {
+                            ThrowHelper.ThrowArgument_StartIndexOutOfBounds();
+                        }
+
+                        computedOffset += (offset * stride);
+                        stride *= length;
+
+                        if (intermediateLengths.Length != 0)
+                        {
+                            intermediateLengths[index] -= offset;
+                        }
+                    }
+                }
+
+                if ((computedOffset < 0) || (computedOffset > linearLength))
+                {
+                    ThrowHelper.ThrowArgument_StartIndexOutOfBounds();
+                }
+
+                TensorShape result = new TensorShape(linearLength - computedOffset, lengths, strides, linearRankOrder: []);
+
+                if (intermediateLengthsArray is not null)
+                {
+                    ArrayPool<nint>.Shared.Return(intermediateLengthsArray);
+                }
+                linearOffset = computedOffset;
+                return result;
+            }
+            else if (start.Length != 0)
+            {
+                ThrowHelper.ThrowArgument_StartIndexOutOfBounds();
+            }
+
+            if ((lengths.Length != 0) || (strides.Length != 0))
+            {
+                ThrowHelper.ThrowArgument_InvalidTensorShape();
+            }
+            linearOffset = computedOffset;
+            return default;
+        }
+
+        public static TensorShape Create(scoped ReadOnlySpan<nint> lengths)
+            => new TensorShape(linearLength: -1, lengths, strides: [], linearRankOrder: []);
+
+        public static TensorShape Create(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+            => new TensorShape(linearLength: -1, lengths, strides, linearRankOrder: []);
+
+        public static TensorShape Create<T>(T[]? array)
+        {
+            if (array is not null)
+            {
+                int linearLength = array.Length;
+
+                return new TensorShape(
+                    flattenedLength: linearLength,
+                    linearLength,
+                    lengths: [linearLength],
+                    strides: [1],
+                    linearRankOrder: [0],
+                    rank: 1,
+                    TensorFlags.IsContiguousAndDense
+                );
+            }
+            return default;
+        }
+
+        public static TensorShape Create<T>(T[]? array, scoped ReadOnlySpan<nint> lengths)
+        {
+            if (array is not null)
+            {
+                int linearLength = array.Length;
+                return new TensorShape(linearLength, lengths, strides: [], linearRankOrder: []);
+            }
+
+            if (lengths.Length != 0)
+            {
+                ThrowHelper.ThrowArgument_InvalidTensorShape();
+            }
+            return default;
+        }
+
+        public static TensorShape Create<T>(T[]? array, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            if (array is not null)
+            {
+                int linearLength = array.Length;
+                return new TensorShape(linearLength, lengths, strides, linearRankOrder: []);
+            }
+
+            if ((lengths.Length != 0) || (strides.Length != 0))
+            {
+                ThrowHelper.ThrowArgument_InvalidTensorShape();
+            }
+            return default;
+        }
+
+        public static TensorShape Create<T>(T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            if (array is not null)
+            {
+                int linearLength = array.Length;
+
+                if ((start < 0) || (start > linearLength))
+                {
+                    ThrowHelper.ThrowArgument_StartIndexOutOfBounds();
+                }
+
+                linearLength -= start;
+                return new TensorShape(linearLength, lengths, strides, linearRankOrder: []);
+            }
+            else if (start != 0)
+            {
+                ThrowHelper.ThrowArgument_StartIndexOutOfBounds();
+            }
+
+            if ((lengths.Length != 0) || (strides.Length != 0))
+            {
+                ThrowHelper.ThrowArgument_InvalidTensorShape();
+            }
+            return default;
+        }
+
+        public static TensorShape Create<T>(T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, scoped ReadOnlySpan<int> linearRankOrder)
+        {
+            if (array is not null)
+            {
+                int linearLength = array.Length;
+
+                if ((start < 0) || (start > linearLength))
+                {
+                    ThrowHelper.ThrowArgument_StartIndexOutOfBounds();
+                }
+
+                linearLength -= start;
+                return new TensorShape(linearLength, lengths, strides, linearRankOrder);
+            }
+            else if (start != 0)
+            {
+                ThrowHelper.ThrowArgument_StartIndexOutOfBounds();
+            }
+
+            if ((lengths.Length != 0) || (strides.Length != 0))
+            {
+                ThrowHelper.ThrowArgument_InvalidTensorShape();
+            }
+            return default;
+        }
+
+        public static TensorShape Create<T>(ref T reference, nint linearLength)
+        {
+            if (!Unsafe.IsNullRef(ref reference))
+            {
+                return new TensorShape(
+                    flattenedLength: linearLength,
+                    linearLength,
+                    lengths: [linearLength],
+                    strides: [1],
+                    linearRankOrder: [0],
+                    rank: 1,
+                    TensorFlags.IsContiguousAndDense
+                );
+            }
+            else if (linearLength != 0)
+            {
+                ThrowHelper.ThrowArgument_LengthIsNonZeroForNullReference();
+            }
+            return default;
+        }
+
+        public static TensorShape Create<T>(ref T reference, nint linearLength, scoped ReadOnlySpan<nint> lengths)
+            => Create(ref reference, linearLength, lengths, strides: [], linearRankOrder: []);
+
+        public static TensorShape Create<T>(ref T reference, nint linearLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+            => Create(ref reference, linearLength, lengths, strides, linearRankOrder: []);
+
+        public static TensorShape Create<T>(ref T reference, nint linearLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, scoped ReadOnlySpan<int> linearRankOrder)
+        {
+            if (!Unsafe.IsNullRef(ref reference))
+            {
+                return new TensorShape(linearLength, lengths, strides, linearRankOrder);
+            }
+            else if (linearLength != 0)
+            {
+                ThrowHelper.ThrowArgument_LengthIsNonZeroForNullReference();
+            }
+
+            if ((lengths.Length != 0) || (strides.Length != 0))
+            {
+                ThrowHelper.ThrowArgument_InvalidTensorShape();
+            }
+            return default;
+        }
+
+        public static unsafe TensorShape Create<T>(T* address, nint linearLength)
+            => Create(ref Unsafe.AsRef<T>(address), linearLength);
+
+        public static unsafe TensorShape Create<T>(T* address, nint linearLength, scoped ReadOnlySpan<nint> lengths)
+            => Create(ref Unsafe.AsRef<T>(address), linearLength, lengths, strides: []);
+
+        public static unsafe TensorShape Create<T>(T* address, nint linearLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+            => Create(ref Unsafe.AsRef<T>(address), linearLength, lengths, strides);
+
+        public override bool Equals([NotNullWhen(true)] object? obj)
+            => (obj is TensorShape other) && (this == other);
+
+        public bool Equals(TensorShape other) => (this == other);
+
+        public override int GetHashCode() => base.GetHashCode();
+
+        [Conditional("DEBUG")]
+        private void ValidateState()
+        {
+            Debug.Assert(IsContiguousAndDense == (FlattenedLength == LinearLength));
+            Debug.Assert(IsBroadcast == Strides.Contains(0));
+        }
+
+        public nint GetLinearOffset<TGetOffsetAndLength, T>(ReadOnlySpan<T> state)
+            where TGetOffsetAndLength : IGetOffsetAndLength<T>
+        {
+            ReadOnlySpan<nint> lengths = Lengths;
+            ReadOnlySpan<nint> strides = Strides;
+
+            if ((state.Length != lengths.Length) ||
+                (state.Length != strides.Length))
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException();
+            }
+
+            nint linearOffset = 0;
+
+            for (int i = 0; i < state.Length; i++)
+            {
+                nint length = lengths[i];
+                nint stride = strides[i];
+
+                nint offset = TGetOffsetAndLength.GetOffset(state, i, length);
+                linearOffset += (offset * stride);
+            }
+
+            return linearOffset;
+        }
+
+        public TensorShape Slice<TGetOffsetAndLength, T>(ReadOnlySpan<T> state, out nint linearOffset)
+            where TGetOffsetAndLength : IGetOffsetAndLength<T>
+        {
+            int rank = Rank;
+
+            nint[]? intermediateLengthsArray = null;
+            InlineBuffer<nint> intermediateLengthsBuffer;
+            scoped Span<nint> intermediateLengths;
+
+            nint[]? intermediateStridesArray = null;
+            InlineBuffer<nint> intermediateStridesBuffer;
+            scoped Span<nint> intermediateStrides;
+
+            if (rank > MaxInlineRank)
+            {
+                intermediateLengthsArray = ArrayPool<nint>.Shared.Rent(rank);
+                intermediateLengths = intermediateLengthsArray.AsSpan(0, rank);
+
+                intermediateStridesArray = ArrayPool<nint>.Shared.Rent(rank);
+                intermediateStrides = intermediateStridesArray.AsSpan(0, rank);
+            }
+            else
+            {
+                Unsafe.SkipInit(out intermediateLengthsBuffer);
+                intermediateLengths = ((Span<nint>)intermediateLengthsBuffer)[..rank];
+
+                Unsafe.SkipInit(out intermediateStridesBuffer);
+                intermediateStrides = ((Span<nint>)intermediateStridesBuffer)[..rank];
+            }
+
+            ReadOnlySpan<nint> previousLengths = Lengths;
+            ReadOnlySpan<nint> previousStrides = Strides;
+            ReadOnlySpan<int> linearRankOrder = LinearRankOrder;
+
+            if ((state.Length != previousLengths.Length) ||
+                (state.Length != linearRankOrder.Length) ||
+                (state.Length != previousStrides.Length))
+            {
+                ThrowHelper.ThrowArgumentOutOfRangeException();
+            }
+
+            // The previous strides and rank order persist in the new shape with
+            // only the lengths having changed based on the new starting index.
+            //
+            // Accordingly, we can also simplify some of the checks as we can
+            // assume that the previousShape is already valid and the new shape
+            // will strictly be the same size or smaller.
+
+            TensorFlags flags = TensorFlags.None;
+
+            nint flattenedLength = 1;
+            nint maximumLinearIndex = 0;
+
+            nint computedOffset = 0;
+
+            for (int i = 0; i < linearRankOrder.Length; i++)
+            {
+                int rankIndex = linearRankOrder.Length - (i + 1);
+                int linearRankIndex = linearRankOrder[rankIndex];
+
+                nint previousLength = previousLengths[linearRankIndex];
+                nint previousStride = previousStrides[linearRankIndex];
+
+                (nint offset, nint length) = TGetOffsetAndLength.GetOffsetAndLength(state, linearRankIndex, previousLength);
+                nint stride = (length > 1) ? previousStride : 0;
+
+                if (stride != 0)
+                {
+                    maximumLinearIndex += ((length - 1) * stride);
+                }
+                else
+                {
+                    flags |= TensorFlags.IsBroadcast;
+                }
+
+                intermediateLengths[linearRankIndex] = length;
+                intermediateStrides[linearRankIndex] = stride;
+
+                computedOffset += (offset * previousStride);
+                flattenedLength *= length;
+            }
+
+            // We've computed the maximum linear index based on the strides
+            // so the minimum length must be one higher than that value.
+
+            nint minimumLinearLength = (flattenedLength != 0) ? (maximumLinearIndex + 1) : flattenedLength;
+            Debug.Assert(minimumLinearLength <= _linearLength);
+
+            if (flattenedLength == minimumLinearLength)
+            {
+                flags |= TensorFlags.IsContiguousAndDense;
+            }
+
+            TensorShape result = new TensorShape(
+                flattenedLength,
+                minimumLinearLength,
+                intermediateLengths,
+                intermediateStrides,
+                linearRankOrder,
+                rank,
+                flags
+            );
+
+            if (intermediateLengthsArray is not null)
+            {
+                ArrayPool<nint>.Shared.Return(intermediateLengthsArray);
+            }
+
+            if (intermediateStridesArray is not null)
+            {
+                ArrayPool<nint>.Shared.Return(intermediateStridesArray);
+            }
+
+            Debug.Assert(computedOffset == GetLinearOffset<TGetOffsetAndLength, T>(state));
+            linearOffset = computedOffset;
+
+            return result;
+        }
+
+        public interface IGetOffsetAndLength<T>
+        {
+            static abstract nint GetOffset(ReadOnlySpan<T> state, int rankIndex, nint previousLength);
+            static abstract (nint Offset, nint Length) GetOffsetAndLength(ReadOnlySpan<T> state, int rankIndex, nint previousLength);
+        }
+
+        [InlineArray(MaxInlineRank)]
+        public struct InlineBuffer<T>
+        {
+            public T e0;
+        }
+
+        public readonly struct GetOffsetAndLengthForNInt : IGetOffsetAndLength<nint>
+        {
+            public static nint GetOffset(ReadOnlySpan<nint> indexes, int rankIndex, nint previousLength)
+            {
+                nint offset = indexes[rankIndex];
+
+                if ((offset < 0) || (offset >= previousLength))
+                {
+                    ThrowHelper.ThrowIndexOutOfRangeException();
+                }
+                return offset;
+            }
+
+            public static (nint Offset, nint Length) GetOffsetAndLength(ReadOnlySpan<nint> indexes, int rankIndex, nint previousLength)
+            {
+                nint offset = GetOffset(indexes, rankIndex, previousLength);
+                return (offset, previousLength - offset);
+            }
+        }
+
+        public readonly struct GetOffsetAndLengthForNIndex : IGetOffsetAndLength<NIndex>
+        {
+            public static nint GetOffset(ReadOnlySpan<NIndex> indexes, int rankIndex, nint previousLength)
+            {
+                nint offset = indexes[rankIndex].GetOffset(previousLength);
+
+                if ((offset < 0) || (offset >= previousLength))
+                {
+                    ThrowHelper.ThrowIndexOutOfRangeException();
+                }
+                return offset;
+            }
+
+            public static (nint Offset, nint Length) GetOffsetAndLength(ReadOnlySpan<NIndex> indexes, int rankIndex, nint previousLength)
+            {
+                nint offset = GetOffset(indexes, rankIndex, previousLength);
+                return (offset, previousLength - offset);
+            }
+        }
+
+        public readonly struct GetOffsetAndLengthForNRange : IGetOffsetAndLength<NRange>
+        {
+            public static nint GetOffset(ReadOnlySpan<NRange> ranges, int rankIndex, nint previousLength)
+            {
+                return ranges[rankIndex].Start.GetOffset(previousLength);
+            }
+
+            public static (nint Offset, nint Length) GetOffsetAndLength(ReadOnlySpan<NRange> ranges, int rankIndex, nint previousLength)
+            {
+                return ranges[rankIndex].GetOffsetAndLength(previousLength);
+            }
+        }
     }
 }
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 a71eaebac3822a..093a922f2f3789 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
@@ -2,14 +2,15 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using EditorBrowsableAttribute = System.ComponentModel.EditorBrowsableAttribute;
-using EditorBrowsableState = System.ComponentModel.EditorBrowsableState;
 
-#pragma warning disable 0809  //warning CS0809: Obsolete member 'TensorSpan<T>.Equals(object)' overrides non-obsolete member 'object.Equals(object)'
+#pragma warning disable CS0809 // Obsolete member overrides non-obsolete member
 
 namespace System.Numerics.Tensors
 {
@@ -22,489 +23,271 @@ namespace System.Numerics.Tensors
     [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
     public readonly ref struct TensorSpan<T>
     {
-        /// <summary>A byref or a native ptr.</summary>
-        internal readonly ref T _reference;
-        internal readonly TensorShape _shape;
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Empty" />
+        public static TensorSpan<T> Empty => default;
 
+        internal readonly TensorShape _shape;
+        internal readonly ref T _reference;
 
-        /// <summary>
-        /// Creates a new span over the entirety of the target array.
-        /// </summary>
-        /// <param name="array">The target array.</param>
-        /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[])" />
         /// <exception cref="ArrayTypeMismatchException"><paramref name="array"/> is covariant and its type is not exactly T[].</exception>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public TensorSpan(T[]? array) : this(array, 0, [array?.Length ?? 0], [])
+        public TensorSpan(T[]? array)
         {
+            ThrowHelper.ThrowIfArrayTypeMismatch<T>(array);
+
+            _shape = TensorShape.Create(array);
+            _reference = ref (array is not null)
+                       ? ref MemoryMarshal.GetArrayDataReference(array)
+                       : ref Unsafe.NullRef<T>();
         }
 
-        /// <summary>
-        /// Creates a new span over the portion of the target array beginning
-        /// at 'start' index and ending at 'end' index (exclusive).
-        /// </summary>
-        /// <param name="array">The target array.</param>
-        /// <param name="startIndex">The index at which to begin the span.</param>
-        /// <param name="lengths">The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data.</param>
-        /// <param name="strides">The strides of each dimension. If default or span of length 0 is provided, then strides will be automatically calculated.</param>
-        /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[], ReadOnlySpan{nint})" />
         /// <exception cref="ArrayTypeMismatchException"><paramref name="array"/> is covariant and its type is not exactly T[].</exception>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// The specified <paramref name="startIndex"/> or end index is not in the range (&lt;0 or &gt;FlattenedLength).
-        /// </exception>
-        public TensorSpan(T[]? array, Index startIndex, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
-            : this(array, startIndex.GetOffset(array?.Length ?? 0), lengths, strides)
+        public TensorSpan(T[]? array, scoped ReadOnlySpan<nint> lengths)
         {
+            ThrowHelper.ThrowIfArrayTypeMismatch<T>(array);
+
+            _shape = TensorShape.Create(array, lengths);
+            _reference = ref (array is not null)
+                       ? ref MemoryMarshal.GetArrayDataReference(array)
+                       : ref Unsafe.NullRef<T>();
         }
 
-        /// <summary>
-        /// Creates a new span over the portion of the target array beginning
-        /// at 'start' index and ending at 'end' index (exclusive).
-        /// </summary>
-        /// <param name="array">The target array.</param>
-        /// <param name="start">The index at which to begin the span.</param>
-        /// <param name="lengths">The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data.</param>
-        /// <param name="strides">The strides of each dimension. If default or span of length 0 is provided, then strides will be automatically calculated.</param>
-        /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[], ReadOnlySpan{nint}, ReadOnlySpan{nint})" />
         /// <exception cref="ArrayTypeMismatchException"><paramref name="array"/> is covariant and its type is not exactly T[].</exception>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// The specified <paramref name="start"/> or end index is not in the range (&lt;0 or &gt;FlattenedLength).
-        /// </exception>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public TensorSpan(T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        public TensorSpan(T[]? array, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
-            if (lengths.IsEmpty && array != null)
-                lengths = [array.Length];
+            ThrowHelper.ThrowIfArrayTypeMismatch<T>(array);
 
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            if (array == null)
-            {
-                if (start != 0 || linearLength != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-                this = default;
-                return; // returns default
-            }
+            _shape = TensorShape.Create(array, lengths, strides);
+            _reference = ref (array is not null)
+                       ? ref MemoryMarshal.GetArrayDataReference(array)
+                       : ref Unsafe.NullRef<T>();
+        }
 
-            if (!typeof(T).IsValueType && array.GetType() != typeof(T[]))
-                ThrowHelper.ThrowArrayTypeMismatchException();
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T[], int, ReadOnlySpan{nint}, ReadOnlySpan{nint})" />
+        /// <exception cref="ArrayTypeMismatchException"><paramref name="array"/> is covariant and its type is not exactly T[].</exception>
+        public TensorSpan(T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            ThrowHelper.ThrowIfArrayTypeMismatch<T>(array);
 
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
-            TensorSpanHelpers.ValidateStrides(strides, lengths);
-            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
+            _shape = TensorShape.Create(array, start, lengths, strides);
+            _reference = ref (array is not null)
+                       ? ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (uint)start)
+                       : ref Unsafe.NullRef<T>();
+        }
 
-            if (Environment.Is64BitProcess)
-            {
-                // See comment in Span<T>.Slice for how this works.
-                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)) && array.Length != 0)
-                    ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
-            }
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(ReadOnlySpan{T})" />
+        public TensorSpan(Span<T> span)
+        {
+            ref T reference = ref MemoryMarshal.GetReference(span);
+            _shape = TensorShape.Create(ref reference, span.Length);
+            _reference = ref reference;
+        }
 
-            _shape = new TensorShape(array.Length - start, lengths, strides);
-            _reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */);
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(ReadOnlySpan{T}, ReadOnlySpan{nint})" />
+        public TensorSpan(Span<T> span, scoped ReadOnlySpan<nint> lengths)
+        {
+            ref T reference = ref MemoryMarshal.GetReference(span);
+            _shape = TensorShape.Create(ref reference, span.Length, lengths);
+            _reference = ref reference;
         }
 
-        /// <summary>
-        /// Creates a new <see cref="TensorSpan{T}"/> over the provided <see cref="Span{T}"/>. The new <see cref="TensorSpan{T}"/> will
-        /// have a rank of 1 and a length equal to the length of the provided <see cref="Span{T}"/>.
-        /// </summary>
-        /// <param name="span">The target span.</param>
-        public TensorSpan(Span<T> span) : this(span, [span.Length], []) { }
-
-        /// <summary>
-        /// Creates a new <see cref="TensorSpan{T}"/> over the provided <see cref="Span{T}"/> using the specified lengths and strides.
-        /// </summary>
-        /// <param name="span">The target span.</param>
-        /// <param name="lengths">The lengths of each dimension.</param>
-        /// <param name="strides">The strides for each dimension. The strides will be automatically calculated if not provided.</param>
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(ReadOnlySpan{T}, ReadOnlySpan{nint}, ReadOnlySpan{nint})" />
         public TensorSpan(Span<T> span, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
-            if (lengths.IsEmpty)
-                lengths = [span.Length];
-
-            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 (span.IsEmpty ? maxElements != 0 : maxElements >= span.Length)
-                ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
-
-            _shape = new TensorShape(span.Length, lengths, strides);
-            _reference = ref MemoryMarshal.GetReference(span);
+            ref T reference = ref MemoryMarshal.GetReference(span);
+            _shape = TensorShape.Create(ref reference, span.Length, lengths, strides);
+            _reference = ref reference;
         }
 
-        /// <summary>
-        /// Creates a new <see cref="TensorSpan{T}"/> over the provided <see cref="Array"/>. The new <see cref="TensorSpan{T}"/> will
-        /// 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,
-                 array == null ?
-                     [0] :
-                     TensorSpanHelpers.FillLengths(array.Rank <= TensorShape.MaxInlineRank ? stackalloc nint[array.Rank] : new nint[array.Rank], array),
-                 [])
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(Array)"/>
+        /// <exception cref="ArrayTypeMismatchException"><paramref name="array"/> is covariant and its type is not exactly T[].</exception>
+        public TensorSpan(Array? array)
         {
+            ThrowHelper.ThrowIfArrayTypeMismatch<T>(array);
+
+            _shape = TensorShape.Create(array);
+            _reference = ref (array is not null)
+                       ? ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array))
+                       : ref Unsafe.NullRef<T>();
         }
 
-        /// <summary>
-        /// Creates a new <see cref="TensorSpan{T}"/> over the provided <see cref="Array"/> using the specified start offsets, lengths, and strides.
-        /// </summary>
-        /// <param name="array">The target array.</param>
-        /// <param name="start">The starting offset for each dimension.</param>
-        /// <param name="lengths">The lengths of each dimension.</param>
-        /// <param name="strides">The strides for each dimension. The strides will be automatically calculated if not provided.</param>
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(Array, ReadOnlySpan{int}, ReadOnlySpan{nint}, ReadOnlySpan{nint})" />
+        /// <exception cref="ArrayTypeMismatchException"><paramref name="array"/> is covariant and its type is not exactly T[].</exception>
         public TensorSpan(Array? array, scoped ReadOnlySpan<int> start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
-            if (lengths.IsEmpty && array != null)
-            {
-                lengths = TensorSpanHelpers.FillLengths(
-                    array.Rank < TensorShape.MaxInlineRank ? stackalloc nint[array.Rank] : new nint[array.Rank],
-                    array);
-            }
-
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-
-            if (array == null)
-            {
-                if (!start.IsEmpty || linearLength != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-                this = default;
-                return; // returns default
-            }
-            if (array.GetType().GetElementType() != typeof(T))
-                ThrowHelper.ThrowArrayTypeMismatchException();
-
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
-            TensorSpanHelpers.ValidateStrides(strides, lengths);
+            ThrowHelper.ThrowIfArrayTypeMismatch<T>(array);
 
-            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 && array.Length != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-            }
-            else
-            {
-                if (((uint)startOffset > (uint)array.Length || (uint)maxElements >= (uint)(array.Length - startOffset)) && array.Length != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-            }
-
-            _shape = new TensorShape(array.Length - startOffset, lengths, strides);
-            _reference = ref Unsafe.Add(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), (nint)(uint)startOffset /* force zero-extension */);
+            _shape = TensorShape.Create(array, start, lengths, strides, out nint linearOffset);
+            _reference = ref (array is not null)
+                       ? ref Unsafe.Add(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), linearOffset)
+                       : ref Unsafe.NullRef<T>();
         }
 
-        /// <summary>
-        /// Creates a new <see cref="TensorSpan{T}"/> over the provided <see cref="Array"/> using the specified start offsets, lengths, and strides.
-        /// </summary>
-        /// <param name="array">The target array.</param>
-        /// <param name="startIndex">The starting offset for each dimension.</param>
-        /// <param name="lengths">The lengths of each dimension.</param>
-        /// <param name="strides">The strides for each dimension. The strides will be automatically calculated if not provided.</param>
-        public TensorSpan(Array? array, scoped ReadOnlySpan<NIndex> startIndex, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T*, nint)" />
+        [CLSCompliant(false)]
+        public unsafe TensorSpan(T* data, nint dataLength)
         {
-            if (lengths.IsEmpty && array != null)
-            {
-                lengths = TensorSpanHelpers.FillLengths(
-                    array.Rank <= TensorShape.MaxInlineRank ? stackalloc nint[array.Rank] : new nint[array.Rank],
-                    array);
-            }
-
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
-            TensorSpanHelpers.ValidateStrides(strides, lengths);
-            if (array == null)
-            {
-                if (!startIndex.IsEmpty || linearLength != 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-                this = default;
-                return; // returns default
-            }
-            if (array.GetType().GetElementType() != typeof(T))
-                ThrowHelper.ThrowArrayTypeMismatchException();
-
-            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)startOffset + (ulong)(uint)maxElements > (ulong)(uint)array.Length)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-            }
-            else
-            {
-                if ((uint)startOffset > (uint)array.Length || (uint)maxElements >= (uint)(array.Length - startOffset))
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-            }
-
-            _shape = new TensorShape(array.Length, lengths, strides);
-            _reference = ref Unsafe.Add(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), (nint)(uint)startOffset /* force zero-extension */);
+            _shape = TensorShape.Create(data, dataLength);
+            _reference = ref Unsafe.AsRef<T>(data);
         }
 
-        /// <summary>
-        /// Creates a new span over the target unmanaged buffer.
-        /// </summary>
-        /// <param name="data">An unmanaged data that points to memory.</param>
-        /// <param name="dataLength">The number of elements the unmanaged memory can hold.</param>
-        /// <remarks>
-        /// This constructor is quite dangerous, because the length is not checked.
-        /// But if this creation is correct, then all subsequent uses are correct.
-        /// </remarks>
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T*, nint, ReadOnlySpan{nint})" />
         [CLSCompliant(false)]
-        public unsafe TensorSpan(T* data, nint dataLength) : this(data, dataLength, [dataLength], []) { }
-
-        /// <summary>
-        /// Creates a new span over the target unmanaged buffer.
-        /// </summary>
-        /// <param name="data">An unmanaged data that points to memory.</param>
-        /// <param name="dataLength">The number of elements the unmanaged memory can hold.</param>
-        /// <param name="lengths">The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data.</param>
-        /// <param name="strides">The lengths of the strides. If nothing is provided, it figures out the default stride configuration.</param>
-        /// <exception cref="ArgumentException">
-        /// <typeparamref name="T"/> is a reference type or contains pointers and hence cannot be stored in unmanaged memory.
-        /// </exception>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// The specified length is negative.
-        /// </exception>
-        /// <remarks>
-        /// This constructor is quite dangerous, because the length is not checked.
-        /// But if this creation is correct, then all subsequent uses are correct.
-        /// </remarks>
+        public unsafe TensorSpan(T* data, nint dataLength, scoped ReadOnlySpan<nint> lengths)
+        {
+            _shape = TensorShape.Create(data, dataLength, lengths);
+            _reference = ref Unsafe.AsRef<T>(data);
+        }
+
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ReadOnlyTensorSpan(T*, nint, ReadOnlySpan{nint}, ReadOnlySpan{nint})" />
         [CLSCompliant(false)]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public unsafe TensorSpan(T* data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
         {
-            if (dataLength < 0)
-                ThrowHelper.ThrowArgumentOutOfRangeException();
-
-            if (RuntimeHelpers.IsReferenceOrContainsReferences<T>())
-                ThrowHelper.ThrowInvalidTypeWithPointersNotSupported(typeof(T));
-
-            if (lengths.IsEmpty)
-                lengths = [dataLength];
-
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
+            _shape = TensorShape.Create(data, dataLength, lengths, strides);
+            _reference = ref Unsafe.AsRef<T>(data);
+        }
 
-            strides = strides.IsEmpty ? (ReadOnlySpan<nint>)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides;
-            TensorSpanHelpers.ValidateStrides(strides, lengths);
+        internal TensorSpan(ref T data, nint dataLength)
+        {
+            _shape = TensorShape.Create(ref data, dataLength);
+            _reference = ref data;
+        }
 
-            nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths);
-            if (maxElements >= dataLength && dataLength != 0)
-                ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
+        internal TensorSpan(ref T data, nint dataLength, scoped ReadOnlySpan<nint> lengths)
+        {
+            _shape = TensorShape.Create(ref data, dataLength, lengths);
+            _reference = ref data;
+        }
 
-            _shape = new TensorShape(dataLength, lengths, strides);
-            _reference = ref *data;
+        internal TensorSpan(ref T data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            _shape = TensorShape.Create(ref data, dataLength, lengths, strides);
+            _reference = ref data;
         }
 
-        // Constructor for internal use only. It is not safe to expose publicly.
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal TensorSpan(ref T reference, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, nint memoryLength)
+        internal TensorSpan(ref T data, nint dataLength, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, scoped ReadOnlySpan<int> linearRankOrder)
         {
-            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
+            _shape = TensorShape.Create(ref data, dataLength, lengths, strides, linearRankOrder);
+            _reference = ref data;
+        }
 
-            _shape = new TensorShape(memoryLength, lengths, strides);
+        internal TensorSpan(ref T reference, scoped in TensorShape shape)
+        {
             _reference = ref reference;
+            _shape = shape;
         }
 
-        /// <summary>
-        /// Returns a reference to specified element of the TensorSpan.
-        /// </summary>
-        /// <param name="indexes"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Any index is less than 0 or greater than or equal to FlattenedLength.
-        /// </exception>
+        /// <inheritdoc cref="ITensor{TSelf, T}.this[ReadOnlySpan{nint}]" />
         public ref T this[params scoped ReadOnlySpan<nint> indexes]
         {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get
-            {
-                if (indexes.Length != Rank)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-
-                nint index = TensorSpanHelpers.ComputeLinearIndex(indexes, Strides, Lengths);
-                if (index >= _shape._memoryLength || index < 0)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-
-                return ref Unsafe.Add(ref _reference, index /* force zero-extension */);
-            }
+            get => ref Unsafe.Add(ref _reference, _shape.GetLinearOffset<TensorShape.GetOffsetAndLengthForNInt, nint>(indexes));
         }
 
-        /// <summary>
-        /// Returns a reference to specified element of the TensorSpan.
-        /// </summary>
-        /// <param name="indexes"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Any index is less than 0 or greater than or equal to FlattenedLength.
-        /// </exception>
+        /// <inheritdoc cref="ITensor{TSelf, T}.this[ReadOnlySpan{NIndex}]" />
         public ref T this[params scoped ReadOnlySpan<NIndex> indexes]
         {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get
-            {
-
-                if (indexes.Length != Rank)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-
-                nint index = TensorSpanHelpers.ComputeLinearIndex(indexes, Strides, Lengths);
-                if (index >= _shape._memoryLength || index < 0)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-
-                return ref Unsafe.Add(ref _reference, index /* force zero-extension */);
-            }
+            get => ref Unsafe.Add(ref _reference, _shape.GetLinearOffset<TensorShape.GetOffsetAndLengthForNIndex, NIndex>(indexes));
         }
 
-        /// <summary>
-        /// Returns a slice of the TensorSpan.
-        /// </summary>
-        /// <param name="ranges"></param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Any index is less than 0 or greater than or equal to FlattenedLength.
-        /// </exception>
+        /// <inheritdoc cref="ITensor{TSelf, T}.this[ReadOnlySpan{NRange}]" />
         public TensorSpan<T> this[params scoped ReadOnlySpan<NRange> ranges]
         {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get
-            {
-                return Slice(ranges);
-            }
-            set
-            {
-                value.CopyTo(this[ranges]);
-            }
+            get => Slice(ranges);
+            set => value.CopyTo(Slice(ranges));
         }
 
-        /// <summary>
-        /// The number of items in the span.
-        /// </summary>
+        /// <inheritdoc cref="IReadOnlyTensor.FlattenedLength" />
         public nint FlattenedLength => _shape.FlattenedLength;
 
-        /// <summary>
-        /// Gets a value indicating whether this <see cref="TensorSpan{T}"/> is empty.
-        /// </summary>
-        /// <value><see langword="true"/> if this span is empty; otherwise, <see langword="false"/>.</value>
+        internal bool IsContiguousAndDense => _shape.IsContiguousAndDense;
+
+        /// <inheritdoc cref="IReadOnlyTensor.IsEmpty" />
         public bool IsEmpty => _shape.IsEmpty;
 
-        /// <summary>
-        /// Gets the length of each dimension in this <see cref="TensorSpan{T}"/>.
-        /// </summary>
+        /// <inheritdoc cref="IReadOnlyTensor.Lengths" />
         [UnscopedRef]
         public ReadOnlySpan<nint> Lengths => _shape.Lengths;
 
-        /// <summary>
-        /// Gets the rank, aka the number of dimensions, of this <see cref="TensorSpan{T}"/>.
-        /// </summary>
+        /// <inheritdoc cref="IReadOnlyTensor.Rank" />
         public int Rank => Lengths.Length;
 
-        /// <summary>
-        /// Gets the strides of this <see cref="TensorSpan{T}"/>
-        /// </summary>
+        /// <inheritdoc cref="IReadOnlyTensor.Strides" />
         [UnscopedRef]
         public ReadOnlySpan<nint> Strides => _shape.Strides;
 
-        /// <summary>
-        /// Compares two spans and returns false if left and right point at the same memory and have the same length.
-        /// This operator does *not* check to see if the *contents* are equal.
-        /// </summary>
-        public static bool operator !=(TensorSpan<T> left, TensorSpan<T> right) => !(left == right);
-
-        /// <summary>
-        /// Compares two spans and returns true if left and right point at the same memory and have the same length.
-        /// This operator does *not* check to see if the *contents* are equal.
-        /// </summary>
-        public static bool operator ==(TensorSpan<T> left, TensorSpan<T> right) =>
-            left._shape.FlattenedLength == right._shape.FlattenedLength &&
-            left.Rank == right.Rank &&
-            left._shape.Lengths.SequenceEqual(right._shape.Lengths) &&
-            left._shape.Strides.SequenceEqual(right._shape.Strides) &&
-            Unsafe.AreSame(ref left._reference, ref right._reference);
-
-        /// <summary>
-        /// This method is not supported as spans cannot be boxed. To compare two spans, use operator ==.
-        /// </summary>
-        /// <exception cref="NotSupportedException">
-        /// In all cases.
-        /// </exception>
-        [Obsolete("Equals() on TensorSpan will always throw an exception. Use the equality operator instead.")]
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        public override bool Equals(object? obj) =>
-            throw new NotSupportedException(SR.NotSupported_CannotCallEqualsOnSpan);
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.operator ==(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+        public static bool operator ==(in TensorSpan<T> left, in TensorSpan<T> right)
+            => Unsafe.AreSame(ref left._reference, ref right._reference)
+            && left._shape == right._shape;
 
-        /// <summary>
-        /// This method is not supported as spans cannot be boxed.
-        /// </summary>
-        /// <exception cref="NotSupportedException">
-        /// In all cases.
-        /// </exception>
-        [Obsolete("GetHashCode() on TensorSpan will always throw an exception.")]
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        public override int GetHashCode() =>
-            throw new NotSupportedException(SR.NotSupported_CannotCallGetHashCodeOnSpan);
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.operator !=(in ReadOnlyTensorSpan{T}, in ReadOnlyTensorSpan{T})" />
+        public static bool operator !=(in TensorSpan<T> left, in TensorSpan<T> right) => !(left == right);
 
-        /// <summary>
-        /// Returns an empty <see cref="TensorSpan{T}"/>
-        /// </summary>
-        public static TensorSpan<T> Empty => default;
+        /// <summary>Defines an implicit conversion of an array to a tensor span.</summary>
+        /// <param name="array">The array to convert to a tensor span.</param>
+        /// <returns>The tensor span that corresponds to <paramref name="array" />.</returns>
+        public static implicit operator TensorSpan<T>(T[]? array) => new TensorSpan<T>(array);
 
-        /// <summary>Gets an enumerator for this span.</summary>
-        public Enumerator GetEnumerator() => new Enumerator(this);
+        /// <summary>Defines an implicit conversion of a tensor to a readonly tensor span.</summary>
+        /// <param name="tensor">The tensor to convert to a readonly tensor span.</param>
+        /// <returns>The tensor that corresponds to <paramref name="tensor" />.</returns>
+        public static implicit operator ReadOnlyTensorSpan<T>(scoped in TensorSpan<T> tensor) =>
+            new ReadOnlyTensorSpan<T>(ref tensor._reference, tensor._shape);
 
-        /// <summary>Enumerates the elements of a <see cref="TensorSpan{T}"/>.</summary>
-        public ref struct Enumerator
-        {
-            /// <summary>The span being enumerated.</summary>
-            private readonly TensorSpan<T> _span;
-            /// <summary>The current index that the enumerator is on.</summary>
-            private Span<nint> _curIndexes;
-            /// <summary>The total item count.</summary>
-            private nint _items;
-
-            /// <summary>Initialize the enumerator.</summary>
-            /// <param name="span">The span to enumerate.</param>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal Enumerator(TensorSpan<T> span)
-            {
-                _span = span;
-                _items = -1;
-                _curIndexes = new nint[_span.Rank];
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.AsReadOnlyTensorSpan()" />
+        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan() => new ReadOnlyTensorSpan<T>(ref _reference, in _shape);
 
-                _curIndexes[_span.Rank - 1] = -1;
-            }
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.AsReadOnlyTensorSpan(ReadOnlySpan{nint})" />
+        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<nint> startIndexes) => AsReadOnlyTensorSpan().Slice(startIndexes);
 
-            /// <summary>Advances the enumerator to the next element of the span.</summary>
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool MoveNext()
-            {
-                TensorSpanHelpers.AdjustIndexes(_span.Rank - 1, 1, _curIndexes, _span.Lengths);
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.AsReadOnlyTensorSpan(ReadOnlySpan{NIndex})" />
+        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NIndex> startIndexes) => AsReadOnlyTensorSpan().Slice(startIndexes);
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.AsReadOnlyTensorSpan(ReadOnlySpan{NRange})" />
+        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NRange> ranges) => AsReadOnlyTensorSpan().Slice(ranges);
 
-                if (_items < _span.FlattenedLength)
-                    _items++;
+        /// <inheritdoc cref="ITensor.Clear()" />
+        public void Clear() => TensorOperation.Invoke<TensorOperation.Clear<T>, T>(this);
 
-                return _items < _span.FlattenedLength;
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.CopyTo(in TensorSpan{T})" />
+        public void CopyTo(scoped in TensorSpan<T> destination)
+        {
+            if (!TryCopyTo(destination))
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
             }
+        }
 
-            /// <summary>Gets the element at the current position of the enumerator.</summary>
-            public ref T Current
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.Equals(object?)" />
+        [Obsolete("Equals() on TensorSpan will always throw an exception. Use the equality operator instead.")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override bool Equals(object? obj) =>
+            throw new NotSupportedException(SR.NotSupported_CannotCallEqualsOnSpan);
+
+        /// <inheritdoc cref="ITensor{TSelf, T}.Fill(T)" />
+        public void Fill(T value) => TensorOperation.Invoke<TensorOperation.Fill<T>, T, T>(this, value);
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.FlattenTo(Span{T})" />
+        public void FlattenTo(scoped Span<T> destination)
+        {
+            if (!TryFlattenTo(destination))
             {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get => ref _span[_curIndexes];
+                ThrowHelper.ThrowArgument_DestinationTooShort();
             }
         }
 
-        /// <summary>
-        /// Returns a reference to the 0th element of the TensorSpan. If the TensorSpan is empty, returns null reference.
-        /// It can be used for pinning and is required to support the use of span within a fixed statement.
-        /// </summary>
+        /// <summary>Gets an enumerator for the tensor span.</summary>
+        public Enumerator GetEnumerator() => new Enumerator(this);
+
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.GetHashCode" />
+        [Obsolete("GetHashCode() on TensorSpan will always throw an exception.")]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public override int GetHashCode() =>
+            throw new NotSupportedException(SR.NotSupported_CannotCallGetHashCodeOnSpan);
+
+        /// <inheritdoc cref="ITensor{TSelf, T}.GetPinnableReference()" />
         [EditorBrowsable(EditorBrowsableState.Never)]
         public ref T GetPinnableReference()
         {
@@ -514,320 +297,108 @@ public ref T GetPinnableReference()
             return ref ret;
         }
 
-        /// <summary>
-        /// Clears the contents of this span.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Clear()
-        {
-            scoped Span<nint> curIndexes;
-            nint[]? curIndexesArray;
-            if (Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexesArray = ArrayPool<nint>.Shared.Rent(Rank);
-                curIndexes = curIndexesArray.AsSpan(0, Rank);
-            }
-            else
-            {
-                curIndexesArray = null;
-                curIndexes = stackalloc nint[Rank];
-            }
-            curIndexes.Clear();
-
-            nint clearedValues = 0;
-            while (clearedValues < _shape.FlattenedLength)
-            {
-                TensorSpanHelpers.Clear(ref Unsafe.Add(ref _reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, Strides, Lengths)), (nuint)Lengths[Rank - 1]);
-                TensorSpanHelpers.AdjustIndexes(Rank - 2, 1, curIndexes, _shape.Lengths);
-                clearedValues += Lengths[Rank - 1];
-            }
-        }
-
-        /// <summary>
-        /// Fills the contents of this span with the given value.
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Fill(T value)
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Slice(ReadOnlySpan{nint})" />
+        public TensorSpan<T> Slice(params scoped ReadOnlySpan<nint> startIndexes)
         {
-            MemoryMarshal.CreateSpan<T>(ref _reference, (int)_shape._memoryLength).Fill(value);
+            TensorShape shape = _shape.Slice<TensorShape.GetOffsetAndLengthForNInt, nint>(startIndexes, out nint linearOffset);
+            return new TensorSpan<T>(
+                ref Unsafe.Add(ref _reference, linearOffset),
+                shape
+            );
         }
 
-        /// <summary>
-        /// Copies the contents of this span into destination span. If the source
-        /// and destinations overlap, this method behaves as if the original values are in
-        /// a temporary location before the destination is overwritten.
-        /// </summary>
-        /// <param name="destination">The span to copy items into.</param>
-        /// <exception cref="ArgumentException">
-        /// The destination TensorSpan is shorter than the source Span.
-        /// </exception>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void CopyTo(scoped TensorSpan<T> destination)
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Slice(ReadOnlySpan{NIndex})" />
+        public TensorSpan<T> Slice(params scoped ReadOnlySpan<NIndex> startIndexes)
         {
-            // Using "if (!TryCopyTo(...))" results in two branches: one for the length
-            // check, and one for the result of TryCopyTo. Since these checks are equivalent,
-            // we can optimize by performing the check once ourselves then calling Memmove directly.
-            if (TensorHelpers.IsBroadcastableTo(Lengths, destination.Lengths))
-            {
-                scoped Span<nint> curIndexes;
-                nint[]? curIndexesArray;
-
-                if (Rank > TensorShape.MaxInlineRank)
-                {
-                    curIndexesArray = ArrayPool<nint>.Shared.Rent(destination.Rank);
-                    curIndexes = curIndexesArray.AsSpan(0, destination.Rank);
-                }
-                else
-                {
-                    curIndexesArray = null;
-                    curIndexes = stackalloc nint[destination.Rank];
-                }
-                curIndexes.Clear();
-
-                nint copiedValues = 0;
-                nint[] tempLengths = Tensor.GetSmallestBroadcastableLengths(Lengths, destination.Lengths);
-
-                TensorSpan<T> destinationSlice = destination.Slice(tempLengths);
-                ReadOnlyTensorSpan<T> srcSlice = Tensor.LazyBroadcast(this, tempLengths);
-                nint copyLength = srcSlice.Strides[^1] == 1 && TensorHelpers.IsContiguousAndDense(srcSlice) ? srcSlice.Lengths[^1] : 1;
-                int indexToAdjust = srcSlice.Strides[^1] == 1 && TensorHelpers.IsContiguousAndDense(srcSlice) ? srcSlice.Rank - 2 : srcSlice.Rank - 1;
-
-                while (copiedValues < destination.FlattenedLength)
-                {
-                    TensorSpanHelpers.Memmove(ref Unsafe.Add(ref destinationSlice._reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, destinationSlice.Strides, destinationSlice.Lengths)), ref Unsafe.Add(ref srcSlice._reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, srcSlice.Strides, srcSlice.Lengths)), copyLength);
-                    TensorSpanHelpers.AdjustIndexes(indexToAdjust, 1, curIndexes, tempLengths);
-                    copiedValues += copyLength;
-                }
-                Debug.Assert(copiedValues == destination.FlattenedLength, "Didn't copy the right amount to the array.");
-
-                if (curIndexesArray != null)
-                    ArrayPool<nint>.Shared.Return(curIndexesArray);
-            }
-            else
-            {
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
-            }
+            TensorShape shape = _shape.Slice<TensorShape.GetOffsetAndLengthForNIndex, NIndex>(startIndexes, out nint linearOffset);
+            return new TensorSpan<T>(
+                ref Unsafe.Add(ref _reference, linearOffset),
+                shape
+            );
         }
 
-        /// <summary>
-        /// Copies the contents of this span into destination span. If the source
-        /// and destinations overlap, this method behaves as if the original values are in
-        /// a temporary location before the destination is overwritten.
-        /// </summary>
-        /// <param name="destination">The span to copy items into.</param>
-        /// <returns>If the destination span is shorter than the source span, this method
-        /// return false and no data is written to the destination.</returns>
-        public bool TryCopyTo(scoped TensorSpan<T> destination)
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Slice(ReadOnlySpan{NRange})" />
+        public TensorSpan<T> Slice(params scoped ReadOnlySpan<NRange> ranges)
         {
-            bool retVal = false;
-
-            if (TensorHelpers.IsBroadcastableTo(Lengths, destination.Lengths))
-            {
-                scoped Span<nint> curIndexes;
-                nint[]? curIndexesArray;
-
-                if (Rank > TensorShape.MaxInlineRank)
-                {
-                    curIndexesArray = ArrayPool<nint>.Shared.Rent(destination.Rank);
-                    curIndexes = curIndexesArray.AsSpan(0, destination.Rank);
-                }
-                else
-                {
-                    curIndexesArray = null;
-                    curIndexes = stackalloc nint[destination.Rank];
-                }
-                curIndexes.Clear();
-
-                nint copiedValues = 0;
-                nint[] tempLengths = Tensor.GetSmallestBroadcastableLengths(Lengths, destination.Lengths);
-
-                TensorSpan<T> destinationSlice = destination.Slice(tempLengths);
-                ReadOnlyTensorSpan<T> srcSlice = Tensor.LazyBroadcast(this, tempLengths);
-                nint copyLength = srcSlice.Strides[^1] == 1 && TensorHelpers.IsContiguousAndDense(srcSlice) ? srcSlice.Lengths[^1] : 1;
-                int indexToAdjust = srcSlice.Strides[^1] == 1 && TensorHelpers.IsContiguousAndDense(srcSlice) ? srcSlice.Rank - 2 : srcSlice.Rank - 1;
-
-                while (copiedValues < destination.FlattenedLength)
-                {
-                    TensorSpanHelpers.Memmove(ref Unsafe.Add(ref destinationSlice._reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, destinationSlice.Strides, destinationSlice.Lengths)), ref Unsafe.Add(ref srcSlice._reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, srcSlice.Strides, srcSlice.Lengths)), copyLength);
-                    TensorSpanHelpers.AdjustIndexes(indexToAdjust, 1, curIndexes, tempLengths);
-                    copiedValues += copyLength;
-                }
-                Debug.Assert(copiedValues == destination.FlattenedLength, "Didn't copy the right amount to the array.");
-                retVal = true;
-
-                if (curIndexesArray != null)
-                    ArrayPool<nint>.Shared.Return(curIndexesArray);
-            }
-            return retVal;
+            TensorShape shape = _shape.Slice<TensorShape.GetOffsetAndLengthForNRange, NRange>(ranges, out nint linearOffset);
+            return new TensorSpan<T>(
+                ref Unsafe.Add(ref _reference, linearOffset),
+                shape
+            );
         }
 
-        /// <summary>
-        /// Implicitly converts an array to a <see cref="TensorSpan{T}"/>.
-        /// </summary>
-        public static implicit operator TensorSpan<T>(T[]? array) => new TensorSpan<T>(array);
+        /// <inheritdoc cref="ReadOnlyTensorSpan{T}.ToString" />
+        public override string ToString() => $"System.Numerics.Tensors.TensorSpan<{typeof(T).Name}>[{_shape}]";
 
-        /// <summary>
-        /// Implicitly converts a <see cref="TensorSpan{T}"/> to a <see cref="ReadOnlyTensorSpan{T}"/>
-        /// </summary>
-        public static implicit operator ReadOnlyTensorSpan<T>(TensorSpan<T> span) =>
-            new ReadOnlyTensorSpan<T>(ref span._reference, span._shape.Lengths, span._shape.Strides, span._shape._memoryLength);
-
-        /// <summary>
-        /// For <see cref="Span{Char}"/>, returns a new instance of string that represents the characters pointed to by the span.
-        /// Otherwise, returns a <see cref="string"/> with the name of the type and the number of elements.
-        /// </summary>
-        public override string ToString() => $"System.Numerics.Tensors.TensorSpan<{typeof(T).Name}>[{_shape.FlattenedLength}]";
-
-        /// <summary>
-        /// Returns a reference to specified element of the TensorSpan.
-        /// </summary>
-        /// <param name="indexes">The indexes for the slice.</param>
-        /// <returns></returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Any index is less than 0 or greater than or equal to <c>FlattenedLength</c>.
-        /// </exception>
-        public TensorSpan<T> Slice(params scoped ReadOnlySpan<NIndex> indexes)
-        {
-            NRange[] ranges = new NRange[indexes.Length];
-            for (int i = 0; i < indexes.Length; i++)
-            {
-                ranges[i] = new NRange(checked((int)indexes[i].GetOffset(Lengths[i])), Lengths[i]);
-            }
-            return Slice(ranges);
-        }
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.TryCopyTo(in TensorSpan{T})" />
+        public bool TryCopyTo(scoped in TensorSpan<T> destination) => AsReadOnlyTensorSpan().TryCopyTo(destination);
 
-        /// <summary>
-        /// Slices a span according to the provided lengths of the dimensions.
-        /// </summary>
-        /// <param name="lengths">The dimension lengths.</param>
-        /// <returns>A <see cref="ReadOnlyTensorSpan{T}"/> based on the provided <paramref name="lengths"/>.</returns>
-        internal TensorSpan<T> Slice(params scoped ReadOnlySpan<nint> lengths)
-        {
-            NRange[] ranges = new NRange[lengths.Length];
-            for (int i = 0; i < lengths.Length; i++)
-            {
-                ranges[i] = new NRange(0, lengths[i]);
-            }
-            return Slice(ranges);
-        }
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.TryFlattenTo(Span{T})" />
+        public bool TryFlattenTo(scoped Span<T> destination) => AsReadOnlyTensorSpan().TryFlattenTo(destination);
 
-        /// <summary>
-        /// Forms a slice out of the given span.
-        /// </summary>
-        /// <param name="ranges">The ranges for the slice.</param>
-        /// <returns>A <see cref="ReadOnlyTensorSpan{T}"/> based on the provided <paramref name="ranges"/>.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public TensorSpan<T> Slice(params scoped ReadOnlySpan<NRange> ranges)
+        /// <summary>Enumerates the elements of a tensor span.</summary>
+        public ref struct Enumerator : IEnumerator<T>
         {
-            if (ranges.Length != Lengths.Length)
-                ThrowHelper.ThrowIndexOutOfRangeException();
-
-            TensorSpan<T> toReturn;
-            scoped Span<nint> lengths;
-            scoped Span<nint> offsets;
-            nint[]? lengthsArray;
-            nint[]? offsetsArray;
-            if (Rank > TensorShape.MaxInlineRank)
-            {
-                lengthsArray = ArrayPool<nint>.Shared.Rent(Rank);
-                lengths = lengthsArray.AsSpan(0, Rank);
+            private readonly TensorSpan<T> _span;
+            private nint[] _indexes;
+            private nint _linearOffset;
+            private nint _itemsEnumerated;
 
-                offsetsArray = ArrayPool<nint>.Shared.Rent(Rank);
-                offsets = offsetsArray.AsSpan(0, Rank);
-            }
-            else
+            internal Enumerator(TensorSpan<T> span)
             {
-                lengths = stackalloc nint[Rank];
-                offsets = stackalloc nint[Rank];
+                _span = span;
+                _indexes = new nint[span.Rank];
 
-                lengthsArray = null;
-                offsetsArray = null;
-            }
-            lengths.Clear();
-            offsets.Clear();
+                _indexes[^1] = -1;
 
-            for (int i = 0; i < ranges.Length; i++)
-            {
-                (offsets[i], lengths[i]) = ranges[i].GetOffsetAndLength(Lengths[i]);
+                _linearOffset = 0 - (!span.IsEmpty ? span.Strides[^1] : 0);
+                _itemsEnumerated = 0;
             }
 
-            // When we have an empty Tensor and someone wants to slice all of it, we should return an empty Tensor.
-            // FlattenedLength is computed everytime so using a local to cache the value.
-            nint flattenedLength = FlattenedLength;
-            nint index = 0;
+            /// <summary>Gets the element at the current position of the enumerator.</summary>
+            public readonly ref T Current => ref Unsafe.Add(ref _span._reference, _linearOffset);
 
-            if (flattenedLength != 0)
+            /// <summary>Advances the enumerator to the next element of the span.</summary>
+            public bool MoveNext()
             {
-                for (int i = 0; i < offsets.Length; i++)
+                if (_itemsEnumerated == _span._shape.FlattenedLength)
                 {
-                    index += Strides[i] * (offsets[i]);
+                    return false;
                 }
-            }
-
-            if ((index >= _shape._memoryLength || index < 0) && flattenedLength != 0)
-                ThrowHelper.ThrowIndexOutOfRangeException();
 
-            toReturn = new TensorSpan<T>(ref Unsafe.Add(ref _reference, index), lengths, _shape.Strides, _shape._memoryLength - index);
+                _linearOffset = _span._shape.AdjustToNextIndex(_span._shape, _linearOffset, _indexes);
 
-            if (offsetsArray != null)
-                ArrayPool<nint>.Shared.Return(offsetsArray);
-            if (lengthsArray != null)
-                ArrayPool<nint>.Shared.Return(lengthsArray);
-
-            return toReturn;
-        }
+                _itemsEnumerated++;
+                return true;
+            }
 
-        /// <summary>
-        /// Flattens the contents of this span into the provided <see cref="Span{T}"/>.
-        /// </summary>
-        /// <param name="destination">The span to copy items into.</param>
-        public bool TryFlattenTo(scoped Span<T> destination)
-        {
-            bool retVal = false;
-            if (destination.Length <= _shape.FlattenedLength)
+            /// <summary>Sets the enumerator to its initial position, which is before the first element in the tensor span.</summary>
+            public void Reset()
             {
-                FlattenTo(destination);
-                retVal = true;
+                Array.Clear(_indexes);
+                _indexes[^1] = -1;
+
+                _linearOffset = 0 - (!_span.IsEmpty ? _span.Strides[^1] : 0);
+                _itemsEnumerated = 0;
             }
-            return retVal;
-        }
 
-        /// <summary>
-        /// Flattens the contents of this span into the provided <see cref="Span{T}"/>.
-        /// </summary>
-        /// <param name="destination">The span to copy items into.</param>
-        public void FlattenTo(scoped Span<T> destination)
-        {
-            if (destination.Length < _shape.FlattenedLength)
-                ThrowHelper.ThrowArgumentException_DestinationTooShort();
+            //
+            // IDisposable
+            //
 
-            if (_shape.FlattenedLength == 0)
-                return;
+            void IDisposable.Dispose() { }
 
-            scoped Span<nint> curIndexes;
-            nint[]? curIndexesArray;
-            if (Rank > TensorShape.MaxInlineRank)
-            {
-                curIndexesArray = ArrayPool<nint>.Shared.Rent(Rank);
-                curIndexes = curIndexesArray.AsSpan(0, Rank);
-            }
-            else
-            {
-                curIndexesArray = null;
-                curIndexes = stackalloc nint[Rank];
-            }
-            curIndexes.Clear();
+            //
+            // IEnumerator
+            //
 
-            nint copiedValues = 0;
-            while (copiedValues < _shape.FlattenedLength)
-            {
-                TensorSpanHelpers.Memmove(destination.Slice(checked((int)copiedValues)), ref Unsafe.Add(ref _reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, Strides, Lengths)), Lengths[Rank - 1]);
-                TensorSpanHelpers.AdjustIndexes(Rank - 2, 1, curIndexes, _shape.Lengths);
-                copiedValues += Lengths[Rank - 1];
-            }
+            readonly object? IEnumerator.Current => Current;
+
+            //
+            // IEnumerator<T>
+            //
 
-            if (curIndexesArray != null)
-                ArrayPool<nint>.Shared.Return(curIndexesArray);
+            readonly T IEnumerator<T>.Current => Current;
         }
     }
 }
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
deleted file mode 100644
index f16e0c033d9a0c..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.T.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace System.Numerics.Tensors
-{
-    internal static partial class TensorSpanHelpers // .T
-    {
-        public static unsafe void Memmove<T>(Span<T> destination, ReadOnlySpan<T> source, nint length, nint dstOffset = 0)
-        {
-            source.Slice(0, checked((int)length)).CopyTo(destination.Slice(checked((int)dstOffset)));
-        }
-
-        public static unsafe void Memmove<T>(ref T[] destination, ref T source, nint length)
-        {
-            MemoryMarshal.CreateSpan(ref source, checked((int)length)).CopyTo(destination);
-        }
-
-        public static unsafe void Memmove<T>(ref T destination, ref T source, nint length)
-        {
-            MemoryMarshal.CreateSpan(ref source, checked((int)length)).CopyTo(MemoryMarshal.CreateSpan(ref destination, checked((int)length)));
-        }
-
-        public static unsafe void Memmove<T>(Span<T> destination, ref T source, nint length)
-        {
-            MemoryMarshal.CreateSpan(ref source, checked((int)length)).CopyTo(destination);
-        }
-
-        public static void Clear<T>(ref T dest, nuint len)
-        {
-            while (len > 0)
-            {
-                nuint toClear = Math.Min(len, int.MaxValue);
-                MemoryMarshal.CreateSpan(ref dest, (int)toClear).Clear();
-                dest = ref Unsafe.Add(ref dest, toClear);
-                len -= toClear;
-            }
-        }
-
-        public static unsafe void Fill<T>(ref T dest, nuint numElements, T value)
-        {
-            while (numElements > 0)
-            {
-                nuint toFill = Math.Min(numElements, int.MaxValue);
-                MemoryMarshal.CreateSpan(ref dest, (int)toFill).Fill(value);
-                dest = ref Unsafe.Add(ref dest, toFill);
-                numElements -= toFill;
-            }
-        }
-    }
-}
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
deleted file mode 100644
index 0d5623eeed8303..00000000000000
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.cs
+++ /dev/null
@@ -1,306 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Buffers;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-
-namespace System.Numerics.Tensors
-{
-
-    [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
-    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._shape.Lengths.SequenceEqual(tensor2._shape.Lengths);
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static nint CalculateTotalLength(ReadOnlySpan<nint> lengths)
-        {
-            if (lengths.IsEmpty)
-                return 0;
-            nint totalLength = 1;
-            for (int i = 0; i < lengths.Length; i++)
-            {
-                if (lengths[i] < 0)
-                    ThrowHelper.ThrowArgumentOutOfRangeException();
-                totalLength *= lengths[i];
-            }
-
-            if (totalLength < 0)
-                ThrowHelper.ThrowArgumentOutOfRangeException();
-
-            return totalLength;
-        }
-
-        /// <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[] 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--)
-            {
-                strides[i] = stride;
-                stride *= lengths[i];
-            }
-
-            return strides;
-        }
-
-        /// <summary>
-        /// Calculates the 1-d index for n-d indexes in layout specified by strides.
-        /// </summary>
-        /// <param name="indexes"></param>
-        /// <param name="strides"></param>
-        /// <param name="lengths"></param>
-        /// <returns></returns>
-        public static nint ComputeLinearIndex(ReadOnlySpan<nint> indexes, ReadOnlySpan<nint> strides, ReadOnlySpan<nint> lengths)
-        {
-            Debug.Assert(strides.Length == indexes.Length);
-
-            nint index = 0;
-            for (int i = 0; i < indexes.Length; i++)
-            {
-                if (indexes[i] >= lengths[i] || indexes[i] < 0)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-                index += strides[i] * indexes[i];
-            }
-
-            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>
-        /// <returns></returns>
-        public static nint ComputeStartOffsetSystemArray(Array array, ReadOnlySpan<int> indexes)
-        {
-            Debug.Assert(array.Rank == indexes.Length || indexes.Length == 0);
-
-            if (indexes.Length == 0)
-                return 0;
-
-            nint index = indexes[indexes.Length - 1];
-            for (int i = indexes.Length - 2; i >= 0; i--)
-            {
-                if ((indexes[i] != 0 && indexes[i] >= array.GetLength(i)) || indexes[i] < 0)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-                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;
-        }
-
-        /// <summary>
-        /// Calculates the 1-d index for n-d indexes in layout specified by strides.
-        /// </summary>
-        /// <param name="indexes"></param>
-        /// <param name="strides"></param>
-        /// <param name="lengths"></param>
-        /// <returns></returns>
-        public static nint ComputeLinearIndex(ReadOnlySpan<NIndex> indexes, ReadOnlySpan<nint> strides, ReadOnlySpan<nint> lengths)
-        {
-            Debug.Assert(strides.Length == indexes.Length);
-
-            nint index = 0;
-            for (int i = 0; i < indexes.Length; i++)
-            {
-                nint offset = indexes[i].GetOffset(lengths[i]);
-                if (offset >= lengths[i] || offset < 0)
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-                index += strides[i] * offset;
-            }
-
-            return index;
-        }
-
-        public static void ValidateStrides(ReadOnlySpan<nint> strides, ReadOnlySpan<nint> lengths)
-        {
-            if (strides.Length != lengths.Length)
-                ThrowHelper.ThrowArgument_InvalidStridesAndLengths();
-
-            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 - 1] == 0)
-                    continue;
-                else if (strides[i - 1] < 0)
-                    ThrowHelper.ThrowArgument_StrideLessThan0();
-                if (strides[i - 1] < strides[i] * lengths[i])
-                    ThrowHelper.ThrowArgument_StrideLessThan0();
-            }
-        }
-
-        /// <summary>
-        /// Takes the span holding the current index and increments it by the addend. If the length of the current spot is greater than the
-        /// length of that dimension then it rolls that over to the next dimension.
-        /// </summary>
-        /// <param name="curIndex">The current index from the indexes we are on.</param>
-        /// <param name="addend">How much we are adding to the <paramref name="curIndex"/></param>
-        /// <param name="curIndexes">The current indexes</param>
-        /// <param name="length">The length of the TensorSpan we are iterating over.</param>
-        public static void AdjustIndexes(int curIndex, nint addend, Span<nint> curIndexes, scoped ReadOnlySpan<nint> length)
-        {
-            if (addend <= 0 || curIndex < 0)
-                return;
-            curIndexes[curIndex] += addend;
-
-            (nint Quotient, nint Remainder) result = Math.DivRem(curIndexes[curIndex], length[curIndex]);
-
-            AdjustIndexes(curIndex - 1, result.Quotient, curIndexes, length);
-            curIndexes[curIndex] = result.Remainder;
-        }
-
-        /// <summary>
-        /// Takes the span holding the current index and increments it by the addend. If the length of the current spot is greater than the
-        /// length of that dimension then it rolls that over to the next dimension.
-        /// </summary>
-        /// <param name="curIndex">The current index from the indexes we are on.</param>
-        /// <param name="addend">How much we are adding to the <paramref name="curIndex"/></param>
-        /// <param name="curIndexes">The current indexes</param>
-        /// <param name="shape">The length of the TensorSpan we are iterating over.</param>
-        public static void AdjustIndexes(int curIndex, nint addend, ref nint[] curIndexes, ReadOnlySpan<nint> shape)
-        {
-            if (addend <= 0 || curIndex < 0)
-                return;
-            curIndexes[curIndex] += addend;
-
-            (nint Quotient, nint Remainder) result = Math.DivRem(curIndexes[curIndex], shape[curIndex]);
-
-            AdjustIndexes(curIndex - 1, result.Quotient, ref curIndexes, shape);
-            curIndexes[curIndex] = result.Remainder;
-        }
-
-        /// <summary>
-        /// Takes the span holding the current index and decrements it by the addend. If the length of the current spot is greater than the
-        /// length of that dimension then it rolls that over to the next dimension.
-        /// </summary>
-        /// <param name="curIndex">The current index from the indexes we are on.</param>
-        /// <param name="addend">How much we are subtracting from the <paramref name="curIndex"/></param>
-        /// <param name="curIndexes">The current indexes</param>
-        /// <param name="shape">The length of the TensorSpan we are iterating over.</param>
-        public static void AdjustIndexesDown(int curIndex, nint addend, Span<nint> curIndexes, ReadOnlySpan<nint> shape)
-        {
-            if (addend <= 0 || curIndex < 0)
-                return;
-
-            curIndexes[curIndex] -= addend;
-            if (curIndexes[curIndex] < 0)
-            {
-                curIndexes[curIndex] = shape[curIndex] - 1;
-                AdjustIndexes(curIndex - 1, 1, curIndexes, shape);
-            }
-        }
-
-        /// <summary>Fills <paramref name="lengths"/> with the corresponding lengths of the ranks in <paramref name="array"/>.</summary>
-        public static ReadOnlySpan<nint> FillLengths(Span<nint> lengths, Array array)
-        {
-            Debug.Assert(array is not null);
-            Debug.Assert(array.Rank == lengths.Length);
-
-            for (int i = 0; i < lengths.Length; i++)
-            {
-                lengths[i] = array.GetLength(i);
-            }
-
-            return lengths;
-        }
-
-        /// <summary>Fills <paramref name="span"/> with values <paramref name="span"/>[i] = i.</summary>
-        public static void FillRange(Span<int> span)
-        {
-            for (int i = 0; i < span.Length; i++)
-            {
-                span[i] = i;
-            }
-        }
-
-        /// <summary>Fills <paramref name="span"/> with values <paramref name="span"/>[i] = i.</summary>
-        public static void FillRange(Span<nint> span)
-        {
-            for (int i = 0; i < span.Length; i++)
-            {
-                span[i] = i;
-            }
-        }
-    }
-}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor_1.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor_1.cs
new file mode 100644
index 00000000000000..a2417ae57f1afe
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor_1.cs
@@ -0,0 +1,451 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace System.Numerics.Tensors
+{
+    /// <summary>
+    /// Represents a tensor.
+    /// </summary>
+    [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)]
+    public sealed class Tensor<T> : ITensor<Tensor<T>, T>
+    {
+        /// <summary>Gets an empty tensor.</summary>
+        public static Tensor<T> Empty { get; } = new();
+
+        internal readonly TensorShape _shape;
+        internal readonly T[] _values;
+
+        internal readonly int _start;
+        internal readonly bool _isPinned;
+
+        internal Tensor(scoped ReadOnlySpan<nint> lengths, bool pinned)
+        {
+            _shape = TensorShape.Create(lengths);
+            _values = GC.AllocateArray<T>(checked((int)(_shape.LinearLength)), pinned);
+
+            _start = 0;
+            _isPinned = pinned;
+        }
+
+        internal Tensor(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned)
+        {
+            _shape = TensorShape.Create(lengths, strides);
+            _values = GC.AllocateArray<T>(checked((int)(_shape.LinearLength)), pinned);
+
+            _start = 0;
+            _isPinned = pinned;
+        }
+
+        internal Tensor(T[]? array)
+        {
+            _shape = TensorShape.Create(array);
+            _values = (array is not null) ? array : [];
+
+            _start = 0;
+            _isPinned = false;
+        }
+
+        internal Tensor(T[]? array, scoped ReadOnlySpan<nint> lengths)
+        {
+            _shape = TensorShape.Create(array, lengths);
+            _values = (array is not null) ? array : [];
+
+            _start = 0;
+            _isPinned = false;
+        }
+
+        internal Tensor(T[]? array, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            _shape = TensorShape.Create(array, lengths, strides);
+            _values = (array is not null) ? array : [];
+
+            _start = 0;
+            _isPinned = false;
+        }
+
+        internal Tensor(T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
+        {
+            _shape = TensorShape.Create(array, start, lengths, strides);
+            _values = (array is not null) ? array : [];
+
+            _start = start;
+            _isPinned = false;
+        }
+
+        internal Tensor(T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, scoped ReadOnlySpan<int> linearRankOrder)
+        {
+            _shape = TensorShape.Create(array, start, lengths, strides, linearRankOrder);
+            _values = (array is not null) ? array : [];
+
+            _start = start;
+            _isPinned = false;
+        }
+
+        internal Tensor(T[] array, in TensorShape shape, bool isPinned)
+        {
+            ThrowHelper.ThrowIfArrayTypeMismatch<T>(array);
+
+            _shape = shape;
+            _values = array;
+
+            _start = 0;
+            _isPinned = isPinned;
+        }
+
+        internal Tensor(T[] array, int start, in TensorShape shape, bool isPinned)
+        {
+            ThrowHelper.ThrowIfArrayTypeMismatch<T>(array);
+
+            _shape = shape;
+            _values = array;
+
+            _start = start;
+            _isPinned = isPinned;
+        }
+
+        private Tensor()
+        {
+            _shape = default;
+            _values = [];
+
+            _start = 0;
+            _isPinned = false;
+        }
+
+        /// <inheritdoc cref="TensorSpan{T}.this[ReadOnlySpan{nint}]" />
+        public ref T this[params scoped ReadOnlySpan<nint> indexes]
+        {
+            get => ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_values), _start + _shape.GetLinearOffset<TensorShape.GetOffsetAndLengthForNInt, nint>(indexes));
+        }
+
+        /// <inheritdoc cref="TensorSpan{T}.this[ReadOnlySpan{NIndex}]" />
+        public ref T this[params scoped ReadOnlySpan<NIndex> indexes]
+        {
+            get => ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_values), _start + _shape.GetLinearOffset<TensorShape.GetOffsetAndLengthForNIndex, NIndex>(indexes));
+        }
+
+        /// <inheritdoc cref="TensorSpan{T}.this[ReadOnlySpan{NRange}]" />
+        public Tensor<T> this[params ReadOnlySpan<NRange> ranges]
+        {
+            get => Slice(ranges);
+            set => value.CopyTo(Slice(ranges));
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor.FlattenedLength" />
+        public nint FlattenedLength => _shape.FlattenedLength;
+
+        internal bool IsContiguousAndDense => _shape.IsContiguousAndDense;
+
+        /// <inheritdoc cref="IReadOnlyTensor.IsEmpty" />
+        public bool IsEmpty => _shape.IsEmpty;
+
+        /// <inheritdoc cref="IReadOnlyTensor.IsPinned" />
+        public bool IsPinned => _isPinned;
+
+        /// <inheritdoc cref="IReadOnlyTensor.Lengths" />
+        public ReadOnlySpan<nint> Lengths => _shape.Lengths;
+
+        /// <inheritdoc cref="IReadOnlyTensor.Rank" />
+        public int Rank => _shape.Rank;
+
+        /// <inheritdoc cref="IReadOnlyTensor.Strides" />
+        public ReadOnlySpan<nint> Strides => _shape.Strides;
+
+        /// <summary>Defines an implicit conversion of an array to a tensor.</summary>
+        /// <param name="array">The array to convert to a tensor.</param>
+        /// <returns>The tensor span that corresponds to <paramref name="array" />.</returns>
+        public static implicit operator Tensor<T>(T[] array) => Tensor.Create(array);
+
+        /// <summary>Defines an implicit conversion of a tensor to a tensor span.</summary>
+        /// <param name="tensor">The tensor to convert to a tensor span.</param>
+        /// <returns>The tensor that corresponds to <paramref name="tensor" />.</returns>
+        public static implicit operator TensorSpan<T>(Tensor<T> tensor) => tensor.AsTensorSpan();
+
+        /// <inheritdoc cref="TensorSpan{T}.implicit operator ReadOnlyTensorSpan{T}(in TensorSpan{T})" />
+        public static implicit operator ReadOnlyTensorSpan<T>(Tensor<T> tensor) => tensor.AsReadOnlyTensorSpan();
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.AsReadOnlyTensorSpan()" />
+        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan() => new ReadOnlyTensorSpan<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_values), _start), in _shape);
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.AsReadOnlyTensorSpan(ReadOnlySpan{nint})" />
+        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<nint> startIndexes) => AsReadOnlyTensorSpan().Slice(startIndexes);
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.AsReadOnlyTensorSpan(ReadOnlySpan{NIndex})" />
+        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NIndex> startIndexes) => AsReadOnlyTensorSpan().Slice(startIndexes);
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.AsReadOnlyTensorSpan(ReadOnlySpan{NRange})" />
+        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NRange> ranges) => AsReadOnlyTensorSpan().Slice(ranges);
+
+        /// <inheritdoc cref="ITensor{TSelf, T}.AsTensorSpan()" />
+        public TensorSpan<T> AsTensorSpan() => new TensorSpan<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_values), _start), in _shape);
+
+        /// <inheritdoc cref="ITensor{TSelf, T}.AsTensorSpan(ReadOnlySpan{nint})" />
+        public TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<nint> startIndexes) => AsTensorSpan().Slice(startIndexes);
+
+        /// <inheritdoc cref="ITensor{TSelf, T}.AsTensorSpan(ReadOnlySpan{NIndex})" />
+        public TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<NIndex> startIndexes) => AsTensorSpan().Slice(startIndexes);
+
+        /// <inheritdoc cref="ITensor{TSelf, T}.AsTensorSpan(ReadOnlySpan{NRange})" />
+        public TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<NRange> ranges) => AsTensorSpan().Slice(ranges);
+
+        /// <inheritdoc cref="ITensor.Clear()" />
+        public unsafe void Clear() => AsTensorSpan().Clear();
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.CopyTo(in TensorSpan{T})" />
+        public void CopyTo(scoped in TensorSpan<T> destination)
+        {
+            if (!TryCopyTo(destination))
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+        }
+
+        /// <inheritdoc cref="ITensor{TSelf, T}.Fill(T)" />
+        public void Fill(T value) => AsTensorSpan().Fill(value);
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.FlattenTo(Span{T})" />
+        public void FlattenTo(scoped Span<T> destination)
+        {
+            if (!TryFlattenTo(destination))
+            {
+                ThrowHelper.ThrowArgument_DestinationTooShort();
+            }
+        }
+
+        /// <summary>Gets an enumerator for the readonly tensor.</summary>
+        public Enumerator GetEnumerator() => new Enumerator(this);
+
+        /// <inheritdoc cref="ITensor{TSelf, T}.GetPinnableReference()" />
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public ref T GetPinnableReference()
+        {
+            // Ensure that the native code has just one forward branch that is predicted-not-taken.
+            ref T ret = ref Unsafe.NullRef<T>();
+            if (_shape.FlattenedLength != 0) ret = ref MemoryMarshal.GetArrayDataReference(_values);
+            return ref ret;
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor.GetPinnedHandle()" />
+        public unsafe MemoryHandle GetPinnedHandle()
+        {
+            GCHandle handle = GCHandle.Alloc(_values, GCHandleType.Pinned);
+            return new MemoryHandle(Unsafe.AsPointer(ref GetPinnableReference()), handle);
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Slice(ReadOnlySpan{nint})" />
+        public Tensor<T> Slice(params ReadOnlySpan<nint> startIndexes)
+        {
+            TensorShape shape = _shape.Slice<TensorShape.GetOffsetAndLengthForNInt, nint>(startIndexes, out nint linearOffset);
+
+            // The source tensor can have no more than int.MaxValue elements so linearOffset will always be in range of int.
+            Debug.Assert((int)(linearOffset) == linearOffset);
+
+            return new Tensor<T>(
+                _values,
+                (int)(_start + linearOffset),
+                in shape,
+                _isPinned
+            );
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Slice(ReadOnlySpan{NIndex})" />
+        public Tensor<T> Slice(params ReadOnlySpan<NIndex> startIndexes)
+        {
+            TensorShape shape = _shape.Slice<TensorShape.GetOffsetAndLengthForNIndex, NIndex>(startIndexes, out nint linearOffset);
+
+            // The source tensor can have no more than int.MaxValue elements so linearOffset will always be in range of int.
+            Debug.Assert((int)(linearOffset) == linearOffset);
+
+            return new Tensor<T>(
+                _values,
+                (int)(_start + linearOffset),
+                in shape,
+                _isPinned
+            );
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.Slice(ReadOnlySpan{NRange})" />
+        public Tensor<T> Slice(params ReadOnlySpan<NRange> ranges)
+        {
+            TensorShape shape = _shape.Slice<TensorShape.GetOffsetAndLengthForNRange, NRange>(ranges, out nint linearOffset);
+
+            // The source tensor can have no more than int.MaxValue elements so linearOffset will always be in range of int.
+            Debug.Assert((int)(linearOffset) == linearOffset);
+
+            return new Tensor<T>(
+                _values,
+                (int)(_start + linearOffset),
+                in shape,
+                _isPinned
+            );
+        }
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.TryCopyTo(in TensorSpan{T})" />
+        public bool TryCopyTo(scoped in TensorSpan<T> destination) => AsReadOnlyTensorSpan().TryCopyTo(destination);
+
+        /// <inheritdoc cref="IReadOnlyTensor{TSelf, T}.TryFlattenTo(Span{T})" />
+        public bool TryFlattenTo(scoped Span<T> destination) => AsReadOnlyTensorSpan().TryFlattenTo(destination);
+
+        /// <summary>
+        /// Creates a <see cref="string"/> representation of the <see cref="TensorSpan{T}"/>."/>
+        /// </summary>
+        /// <param name="maximumLengths">Maximum Length of each dimension</param>
+        /// <returns>A <see cref="string"/> representation of the <see cref="Tensor{T}"/></returns>
+        public string ToString(params ReadOnlySpan<nint> maximumLengths)
+        {
+            var sb = new StringBuilder($"System.Numerics.Tensors.Tensor<{typeof(T).Name}>[{_shape}]");
+
+            sb.AppendLine("{");
+            Tensor.ToString(AsReadOnlyTensorSpan(), maximumLengths, sb);
+            sb.AppendLine("}");
+
+            return sb.ToString();
+        }
+
+        //
+        // IEnumerable
+        //
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        //
+        // IEnumerable<T>
+        //
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
+
+        //
+        // IReadOnlyTensor
+        //
+
+        object? IReadOnlyTensor.this[params scoped ReadOnlySpan<NIndex> indexes] => this[indexes];
+
+        object? IReadOnlyTensor.this[params scoped ReadOnlySpan<nint> indexes] => this[indexes];
+
+        //
+        // IReadOnlyTensor<TSelf, T>
+        //
+
+        ref readonly T IReadOnlyTensor<Tensor<T>, T>.this[params ReadOnlySpan<nint> indexes] => ref this[indexes];
+
+        ref readonly T IReadOnlyTensor<Tensor<T>, T>.this[params ReadOnlySpan<NIndex> indexes] => ref this[indexes];
+
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        ref readonly T IReadOnlyTensor<Tensor<T>, T>.GetPinnableReference() => ref GetPinnableReference();
+
+        //
+        // ITensor
+        //
+
+        bool ITensor.IsReadOnly => false;
+
+        object? ITensor.this[params scoped ReadOnlySpan<NIndex> indexes]
+        {
+            get => this[indexes];
+
+            set
+            {
+                this[indexes] = (T)value!;
+            }
+        }
+
+        object? ITensor.this[params scoped ReadOnlySpan<nint> indexes]
+        {
+            get => this[indexes];
+
+            set
+            {
+                this[indexes] = (T)value!;
+            }
+        }
+
+        void ITensor.Fill(object value) => Fill(value is T t ? t : throw new ArgumentException($"Cannot convert {value} to {typeof(T)}"));
+
+        //
+        // ITensor<TSelf, T>
+        //
+
+        static Tensor<T> ITensor<Tensor<T>, T>.Create(scoped ReadOnlySpan<nint> lengths, bool pinned) => Tensor.Create<T>(lengths, pinned);
+
+        static Tensor<T> ITensor<Tensor<T>, T>.Create(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned) => Tensor.Create<T>(lengths, strides, pinned);
+
+        static Tensor<T> ITensor<Tensor<T>, T>.CreateUninitialized(scoped ReadOnlySpan<nint> lengths, bool pinned) => Tensor.Create<T>(lengths, pinned);
+
+        static Tensor<T> ITensor<Tensor<T>, T>.CreateUninitialized(scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides, bool pinned) => Tensor.Create<T>(lengths, strides, pinned);
+
+        /// <summary>Enumerates the elements of a tensor.</summary>
+        public struct Enumerator : IEnumerator<T>
+        {
+            private readonly Tensor<T> _tensor;
+            private nint[] _indexes;
+            private nint _linearOffset;
+            private nint _itemsEnumerated;
+
+            internal Enumerator(Tensor<T> tensor)
+            {
+                _tensor = tensor;
+                _indexes = new nint[tensor.Rank];
+
+                _indexes[^1] = -1;
+
+                _linearOffset = tensor._start - (!tensor.IsEmpty ? tensor.Strides[^1] : 0);
+                _itemsEnumerated = 0;
+            }
+
+            /// <inheritdoc cref="IEnumerator{T}.Current" />
+            public readonly ref T Current => ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(_tensor._values), _linearOffset);
+
+            /// <inheritdoc cref="IEnumerator.MoveNext()" />
+            public bool MoveNext()
+            {
+                if (_itemsEnumerated == _tensor._shape.FlattenedLength)
+                {
+                    return false;
+                }
+
+                _linearOffset = _tensor._shape.AdjustToNextIndex(_tensor._shape, _linearOffset, _indexes);
+
+                _itemsEnumerated++;
+                return true;
+            }
+
+            /// <inheritdoc cref="IEnumerator.Reset()" />
+            public void Reset()
+            {
+                Array.Clear(_indexes);
+                _indexes[^1] = -1;
+
+                _linearOffset = _tensor._start - (!_tensor.IsEmpty ? _tensor.Strides[^1] : 0);
+                _itemsEnumerated = 0;
+            }
+
+            //
+            // IDisposable
+            //
+
+            readonly void IDisposable.Dispose() { }
+
+            //
+            // IEnumerator
+            //
+
+            readonly object? IEnumerator.Current => Current;
+
+            //
+            // IEnumerator<T>
+            //
+
+            readonly T IEnumerator<T>.Current => Current;
+        }
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs b/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs
index d2396172fb606e..81338921a5810d 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs
@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 
 namespace System
 {
@@ -28,6 +29,22 @@ public static void ThrowArgument_SpansMustBeNonEmpty() =>
         public static void ThrowArgument_InputAndDestinationSpanMustNotOverlap() =>
             throw new ArgumentException(SR.Argument_InputAndDestinationSpanMustNotOverlap, "destination");
 
+        public static void ThrowIfArrayTypeMismatch<T>(Array? array)
+        {
+            if ((array is not null) && (array.GetType().GetElementType() != typeof(T)))
+            {
+                ThrowArrayTypeMismatchException();
+            }
+        }
+
+        public static void ThrowIfArrayTypeMismatch<T>(T[]? array)
+        {
+            if ((array is not null) && !typeof(T).IsValueType && (array.GetType() != typeof(T[])))
+            {
+                ThrowArrayTypeMismatchException();
+            }
+        }
+
         [DoesNotReturn]
         public static void ThrowArgument_DestinationSpansMustNotOverlap() =>
             throw new ArgumentException(SR.Argument_DestinationSpansMustNotOverlap);
@@ -57,13 +74,19 @@ internal static void ThrowIndexOutOfRangeException()
         }
 
         [DoesNotReturn]
-        public static void ThrowArgumentException_DestinationTooShort()
+        public static void ThrowArgument_LengthsMustEqualArrayLength()
         {
-            throw GetArgumentException(SR.DestinationTooShort);
+            throw new ArgumentOutOfRangeException();
         }
 
         [DoesNotReturn]
-        public static void ThrowArgument_LengthsMustEqualArrayLength()
+        public static void ThrowArgument_LengthIsNegative()
+        {
+            throw new ArgumentOutOfRangeException();
+        }
+
+        [DoesNotReturn]
+        public static void ThrowArgument_StartIndexOutOfBounds()
         {
             throw new ArgumentOutOfRangeException();
         }
@@ -102,9 +125,9 @@ public static void ThrowArgument_SetSliceInvalidShapes(string? paramNames)
         }
 
         [DoesNotReturn]
-        public static void ThrowArgument_LengthsNotBroadcastCompatible()
+        public static void ThrowArgument_LengthsNotCompatible()
         {
-            throw new ArgumentException(SR.ThrowArgument_LengthsNotBroadcastCompatible);
+            throw new ArgumentException(SR.ThrowArgument_LengthsNotCompatible);
         }
 
         [DoesNotReturn]
@@ -204,13 +227,19 @@ public static void ThrowArgument_InPlaceInvalidShape()
         }
 
         [DoesNotReturn]
-        public static void ThrowArgument_InvalidStridesAndLengths()
+        public static void ThrowArgument_InvalidTensorShape()
         {
             throw new ArgumentException(SR.ThrowArgument_InvalidStridesAndLengths);
         }
 
         [DoesNotReturn]
-        public static void ThrowArgument_StrideLessThan0()
+        public static void ThrowArgument_LengthIsNonZeroForNullReference()
+        {
+            throw new ArgumentOutOfRangeException(SR.ThrowArgument_LengthIsNonZeroForNullReference);
+        }
+
+        [DoesNotReturn]
+        public static void ThrowArgument_StrideIsNegative()
         {
             throw new ArgumentOutOfRangeException(SR.ThrowArgument_StrideLessThan0);
         }
diff --git a/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs b/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs
index d88ccfb9a7fbe6..1a3b5fd8825a68 100644
--- a/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs
@@ -5,8 +5,6 @@
 using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Xunit;
 
 namespace System.Numerics.Tensors.Tests
@@ -191,7 +189,7 @@ public static void ReadOnlyTensorSpanSystemArrayConstructorTests()
             Assert.Equal(-93, spanInt[1, 1]);
 
             // Make sure you can't overlap elements using strides
-            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            Assert.Throws<ArgumentException>(() =>
             {
                 var spanInt = new ReadOnlyTensorSpan<int>(a, (int[])[], [2, 2], [1, 1]);
             });
@@ -206,34 +204,34 @@ public static void ReadOnlyTensorSpanSystemArrayConstructorTests()
             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]);
+            // // TODO: 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]);
+
+            // // TODO: 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 exception is thrown if lengths and strides would let you go past the end of the array
-            Assert.Throws<ArgumentException>(() => new TensorSpan<double>(new double[0], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 }));
-            Assert.Throws<ArgumentException>(() => new TensorSpan<double>(new double[1], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 }));
-            Assert.Throws<ArgumentException>(() => new TensorSpan<double>(new double[2], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 2 }));
+            Assert.Throws<ArgumentOutOfRangeException>(() => new TensorSpan<double>(new double[0], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 }));
+            Assert.Throws<ArgumentOutOfRangeException>(() => new TensorSpan<double>(new double[1], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 }));
+            Assert.Throws<ArgumentOutOfRangeException>(() => new TensorSpan<double>(new double[2], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 2 }));
 
             // Make sure basic T[] constructor works
             int[] a = { 91, 92, -93, 94 };
@@ -259,7 +257,7 @@ public static void ReadOnlyTensorSpanArrayConstructorTests()
             Assert.Equal(1, spanInt.Rank);
             Assert.Equal(0, spanInt.Lengths[0]);
             Assert.Equal(0, spanInt.FlattenedLength);
-            Assert.Equal(0, spanInt.Strides[0]);
+            Assert.Equal(1, spanInt.Strides[0]);
             // Make sure it still throws on index 0
             Assert.Throws<IndexOutOfRangeException>(() => {
                 var spanInt = new ReadOnlyTensorSpan<int>(b);
@@ -275,7 +273,7 @@ public static void ReadOnlyTensorSpanArrayConstructorTests()
             Assert.Equal(0, spanInt.Strides[0]);
 
             // Make sure 2D array works
-            spanInt = new ReadOnlyTensorSpan<int>(a, new Index(0), [2,2], default);
+            spanInt = new ReadOnlyTensorSpan<int>(a, 0, [2,2], default);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(2, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -285,24 +283,24 @@ public static void ReadOnlyTensorSpanArrayConstructorTests()
             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);
+            spanInt = new ReadOnlyTensorSpan<int>(a, 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 spanInt = new ReadOnlyTensorSpan<int>(a, 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 spanInt = new ReadOnlyTensorSpan<int>(a, 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);
+            spanInt = new ReadOnlyTensorSpan<int>(a, 1, [1, 2], default);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(1, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -310,7 +308,7 @@ public static void ReadOnlyTensorSpanArrayConstructorTests()
             Assert.Equal(-93, spanInt[0, 1]);
 
             // Make sure Index offset works correctly
-            spanInt = new ReadOnlyTensorSpan<int>(a, new Index(2), [1, 2], default);
+            spanInt = new ReadOnlyTensorSpan<int>(a, 2, [1, 2], default);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(1, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -318,12 +316,12 @@ public static void ReadOnlyTensorSpanArrayConstructorTests()
             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);
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new ReadOnlyTensorSpan<int>(a, 3, [1, 2], default);
             });
 
             // Make sure 2D array works with basic strides
-            spanInt = new ReadOnlyTensorSpan<int>(a, new Index(0), [2, 2], [2, 1]);
+            spanInt = new ReadOnlyTensorSpan<int>(a, 0, [2, 2], [2, 1]);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(2, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -333,7 +331,7 @@ public static void ReadOnlyTensorSpanArrayConstructorTests()
             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]);
+            spanInt = new ReadOnlyTensorSpan<int>(a, 0, [2, 2], [0, 1]);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(2, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -343,7 +341,7 @@ public static void ReadOnlyTensorSpanArrayConstructorTests()
             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]);
+            spanInt = new ReadOnlyTensorSpan<int>(a, 2, [2, 2], [0, 1]);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(2, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -353,7 +351,7 @@ public static void ReadOnlyTensorSpanArrayConstructorTests()
             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]);
+            spanInt = new ReadOnlyTensorSpan<int>(a, 3, [2, 2], [0, 0]);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(2, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -364,18 +362,18 @@ public static void ReadOnlyTensorSpanArrayConstructorTests()
 
             // Make sure strides can't be negative
             Assert.Throws<ArgumentOutOfRangeException>(() => {
-                var spanInt = new ReadOnlyTensorSpan<int>(a, new Index(3), [1, 2], [-1, 0]);
+                var spanInt = new ReadOnlyTensorSpan<int>(a, 3, [1, 2], [-1, 0]);
             });
             Assert.Throws<ArgumentOutOfRangeException>(() => {
-                var spanInt = new ReadOnlyTensorSpan<int>(a, new Index(3), [1, 2], [0, -1]);
+                var spanInt = new ReadOnlyTensorSpan<int>(a, 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], []);
+                var spanInt = new ReadOnlyTensorSpan<int>(a, 3, [-1, 2], []);
             });
             Assert.Throws<ArgumentOutOfRangeException>(() => {
-                var spanInt = new ReadOnlyTensorSpan<int>(a, new Index(3), [1, -2], []);
+                var spanInt = new ReadOnlyTensorSpan<int>(a, 3, [1, -2], []);
             });
 
             // Make sure 2D array works with strides to hit element 0,0,2,2
@@ -389,7 +387,7 @@ public static void ReadOnlyTensorSpanArrayConstructorTests()
             Assert.Equal(-93, spanInt[1, 1]);
 
             // Make sure you can't overlap elements using strides
-            Assert.Throws<ArgumentOutOfRangeException>(() => {
+            Assert.Throws<ArgumentException>(() => {
                 var spanInt = new ReadOnlyTensorSpan<int>(a, 0, [2, 2], [1, 1]);
             });
         }
@@ -411,12 +409,12 @@ public static void ReadOnlyTensorSpanSpanConstructorTests()
             // 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.Rank);
+            Assert.Equal(0, spanInt.Lengths.Length);
             Assert.Equal(0, spanInt.FlattenedLength);
-            Assert.Equal(0, spanInt.Strides[0]);
+            Assert.Equal(0, spanInt.Strides.Length);
             // Make sure it still throws on index 0
-            Assert.Throws<IndexOutOfRangeException>(() => {
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
                 Span<int> b = [];
                 var spanInt = new ReadOnlyTensorSpan<int>(b);
                 var x = spanInt[0];
@@ -468,7 +466,7 @@ public static void ReadOnlyTensorSpanSpanConstructorTests()
             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>(() => {
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
                 Span<int> a = [91, 92, -93, 94];
                 var spanInt = new ReadOnlyTensorSpan<int>(a.Slice(3), [1, 2], default);
             });
@@ -544,7 +542,7 @@ public static void ReadOnlyTensorSpanSpanConstructorTests()
             Assert.Equal(-93, spanInt[1, 1]);
 
             // Make sure you can't overlap elements using strides
-            Assert.Throws<ArgumentOutOfRangeException>(() => {
+            Assert.Throws<ArgumentException>(() => {
                 Span<int> a = [91, 92, -93, 94];
                 var spanInt = new ReadOnlyTensorSpan<int>(a, [2, 2], [1, 1]);
             });
@@ -573,12 +571,12 @@ public static unsafe void ReadOnlyTensorSpanPointerConstructorTests()
             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.Rank);
+                Assert.Equal(0, spanInt.Lengths.Length);
                 Assert.Equal(0, spanInt.FlattenedLength);
-                Assert.Equal(0, spanInt.Strides[0]);
+                Assert.Equal(0, spanInt.Strides.Length);
                 // Make sure it still throws on index 0
-                Assert.Throws<IndexOutOfRangeException>(() =>
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
                 {
                     Span<int> b = [];
                     fixed (int* p = b)
@@ -646,7 +644,7 @@ public static unsafe void ReadOnlyTensorSpanPointerConstructorTests()
                 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>(() =>
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
                 {
                     Span<int> a = [91, 92, -93, 94];
                     fixed (int* p = a)
@@ -752,7 +750,7 @@ public static unsafe void ReadOnlyTensorSpanPointerConstructorTests()
                 Assert.Equal(-93, spanInt[1, 1]);
 
                 // Make sure you can't overlap elements using strides
-                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                Assert.Throws<ArgumentException>(() =>
                 {
                     Span<int> a = [91, 92, -93, 94];
                     fixed (int* p = a)
@@ -768,7 +766,7 @@ public static void ReadOnlyTensorSpanLargeDimensionsTests()
         {
             int[] a = { 91, 92, -93, 94, 95, -96 };
             int[] results = new int[6];
-            ReadOnlyTensorSpan<int> spanInt = a.AsTensorSpan(1, 1, 1, 1, 1, 6);
+            ReadOnlyTensorSpan<int> spanInt = a.AsTensorSpan([1, 1, 1, 1, 1, 6]);
             Assert.Equal(6, spanInt.Rank);
 
             Assert.Equal(6, spanInt.Lengths.Length);
@@ -779,11 +777,11 @@ public static void ReadOnlyTensorSpanLargeDimensionsTests()
             Assert.Equal(1, spanInt.Lengths[4]);
             Assert.Equal(6, spanInt.Lengths[5]);
             Assert.Equal(6, spanInt.Strides.Length);
-            Assert.Equal(6, spanInt.Strides[0]);
-            Assert.Equal(6, spanInt.Strides[1]);
-            Assert.Equal(6, spanInt.Strides[2]);
-            Assert.Equal(6, spanInt.Strides[3]);
-            Assert.Equal(6, spanInt.Strides[4]);
+            Assert.Equal(0, spanInt.Strides[0]);
+            Assert.Equal(0, spanInt.Strides[1]);
+            Assert.Equal(0, spanInt.Strides[2]);
+            Assert.Equal(0, spanInt.Strides[3]);
+            Assert.Equal(0, spanInt.Strides[4]);
             Assert.Equal(1, spanInt.Strides[5]);
             Assert.Equal(91, spanInt[0, 0, 0, 0, 0, 0]);
             Assert.Equal(92, spanInt[0, 0, 0, 0, 0, 1]);
@@ -796,7 +794,7 @@ public static void ReadOnlyTensorSpanLargeDimensionsTests()
 
             a = [91, 92, -93, 94, 95, -96, -91, -92, 93, -94, -95, 96];
             results = new int[12];
-            spanInt = a.AsTensorSpan(1, 2, 2, 1, 1, 3);
+            spanInt = a.AsTensorSpan([1, 2, 2, 1, 1, 3]);
             Assert.Equal(6, spanInt.Lengths.Length);
             Assert.Equal(1, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -805,11 +803,11 @@ public static void ReadOnlyTensorSpanLargeDimensionsTests()
             Assert.Equal(1, spanInt.Lengths[4]);
             Assert.Equal(3, spanInt.Lengths[5]);
             Assert.Equal(6, spanInt.Strides.Length);
-            Assert.Equal(12, spanInt.Strides[0]);
+            Assert.Equal(0, spanInt.Strides[0]);
             Assert.Equal(6, spanInt.Strides[1]);
             Assert.Equal(3, spanInt.Strides[2]);
-            Assert.Equal(3, spanInt.Strides[3]);
-            Assert.Equal(3, spanInt.Strides[4]);
+            Assert.Equal(0, spanInt.Strides[3]);
+            Assert.Equal(0, spanInt.Strides[4]);
             Assert.Equal(1, spanInt.Strides[5]);
             Assert.Equal(91, spanInt[0, 0, 0, 0, 0, 0]);
             Assert.Equal(92, spanInt[0, 0, 0, 0, 0, 1]);
@@ -832,7 +830,7 @@ public static void IntArrayAsReadOnlyTensorSpan()
         {
             int[] a = { 91, 92, -93, 94 };
             int[] results = new int[4];
-            ReadOnlyTensorSpan<int> spanInt = a.AsTensorSpan(4);
+            ReadOnlyTensorSpan<int> spanInt = a.AsTensorSpan([4]);
             Assert.Equal(1, spanInt.Rank);
 
             Assert.Equal(1, spanInt.Lengths.Length);
@@ -850,7 +848,7 @@ public static void IntArrayAsReadOnlyTensorSpan()
             a[1] = 92;
             a[2] = -93;
             a[3] = 94;
-            spanInt = a.AsTensorSpan(2, 2);
+            spanInt = a.AsTensorSpan([2, 2]);
             spanInt.FlattenTo(results);
             Assert.Equal(a, results);
             Assert.Equal(2, spanInt.Rank);
@@ -871,8 +869,8 @@ public static void ReadOnlyTensorSpanCopyTest()
         {
             int[] leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             int[] rightData = new int[9];
-            ReadOnlyTensorSpan<int> leftSpan = leftData.AsTensorSpan(3, 3);
-            TensorSpan<int> rightSpan = rightData.AsTensorSpan(3, 3);
+            ReadOnlyTensorSpan<int> leftSpan = leftData.AsTensorSpan([3, 3]);
+            TensorSpan<int> rightSpan = rightData.AsTensorSpan([3, 3]);
             leftSpan.CopyTo(rightSpan);
             var leftEnum = leftSpan.GetEnumerator();
             var rightEnum = rightSpan.GetEnumerator();
@@ -890,16 +888,16 @@ public static void ReadOnlyTensorSpanCopyTest()
             {
                 leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
                 rightData = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-                TensorSpan<int> leftSpan = leftData.AsTensorSpan(9);
-                TensorSpan<int> tensor = rightData.AsTensorSpan(rightData.Length);
+                TensorSpan<int> leftSpan = leftData.AsTensorSpan([9]);
+                TensorSpan<int> tensor = rightData.AsTensorSpan([rightData.Length]);
                 leftSpan.CopyTo(tensor);
             }
             );
 
             leftData = [.. Enumerable.Range(0, 27)];
             rightData = [.. Enumerable.Range(0, 27)];
-            leftSpan = leftData.AsTensorSpan(3, 3, 3);
-            rightSpan = rightData.AsTensorSpan(3, 3, 3);
+            leftSpan = leftData.AsTensorSpan([3, 3, 3]);
+            rightSpan = rightData.AsTensorSpan([3, 3, 3]);
             leftSpan.CopyTo(rightSpan);
 
             while (leftEnum.MoveNext() && rightEnum.MoveNext())
@@ -909,7 +907,7 @@ public static void ReadOnlyTensorSpanCopyTest()
 
             Assert.Throws<ArgumentException>(() =>
             {
-                var l = leftData.AsTensorSpan(3, 3, 3);
+                var l = leftData.AsTensorSpan([3, 3, 3]);
                 var r = new TensorSpan<int>();
                 l.CopyTo(r);
             });
@@ -920,8 +918,8 @@ public static void ReadOnlyTensorSpanTryCopyTest()
         {
             int[] leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             int[] rightData = new int[9];
-            ReadOnlyTensorSpan<int> leftSpan = leftData.AsTensorSpan(3, 3);
-            TensorSpan<int> rightSpan = rightData.AsTensorSpan(3, 3);
+            ReadOnlyTensorSpan<int> leftSpan = leftData.AsTensorSpan([3, 3]);
+            TensorSpan<int> rightSpan = rightData.AsTensorSpan([3, 3]);
             var success = leftSpan.TryCopyTo(rightSpan);
             Assert.True(success);
             var leftEnum = leftSpan.GetEnumerator();
@@ -937,15 +935,15 @@ public static void ReadOnlyTensorSpanTryCopyTest()
 
             leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             rightData = new int[15];
-            leftSpan = leftData.AsTensorSpan(9);
-            rightSpan = rightData.AsTensorSpan(15);
+            leftSpan = leftData.AsTensorSpan([9]);
+            rightSpan = rightData.AsTensorSpan([15]);
             success = leftSpan.TryCopyTo(rightSpan);
             Assert.False(success);
 
             leftData = [.. Enumerable.Range(0, 27)];
             rightData = [.. Enumerable.Range(0, 27)];
-            leftSpan = leftData.AsTensorSpan(3, 3, 3);
-            rightSpan = rightData.AsTensorSpan(3, 3, 3);
+            leftSpan = leftData.AsTensorSpan([3, 3, 3]);
+            rightSpan = rightData.AsTensorSpan([3, 3, 3]);
             success = leftSpan.TryCopyTo(rightSpan);
             Assert.True(success);
 
@@ -954,7 +952,7 @@ public static void ReadOnlyTensorSpanTryCopyTest()
                 Assert.Equal(leftEnum.Current, rightEnum.Current);
             }
 
-            var l = leftData.AsTensorSpan(3, 3, 3);
+            var l = leftData.AsTensorSpan([3, 3, 3]);
             var r = new TensorSpan<int>();
             success = l.TryCopyTo(r);
             Assert.False(success);
@@ -1014,11 +1012,11 @@ public static void ReadOnlyTensorSpanSliceTest()
 
             int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             int[] results = new int[9];
-            ReadOnlyTensorSpan<int> spanInt = a.AsTensorSpan(3, 3);
+            ReadOnlyTensorSpan<int> spanInt = a.AsTensorSpan([3, 3]);
 
-            Assert.Throws<IndexOutOfRangeException>(() => a.AsTensorSpan(2, 3).Slice(0..1));
-            Assert.Throws<IndexOutOfRangeException>(() => a.AsTensorSpan(2, 3).Slice(1..2));
-            Assert.Throws<ArgumentOutOfRangeException>(() => a.AsTensorSpan(2, 3).Slice(0..1, 5..6));
+            Assert.Throws<ArgumentOutOfRangeException>(() => a.AsTensorSpan([2, 3]).Slice(0..1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => a.AsTensorSpan([2, 3]).Slice(1..2));
+            Assert.Throws<ArgumentOutOfRangeException>(() => a.AsTensorSpan([2, 3]).Slice(0..1, 5..6));
 
             var sp = spanInt.Slice(1..3, 1..3);
             Assert.Equal(5, sp[0, 0]);
@@ -1058,7 +1056,7 @@ public static void ReadOnlyTensorSpanSliceTest()
 
             sp = spanInt.Slice(0..1, 0..1);
             Assert.Equal(1, sp[0, 0]);
-            Assert.Throws<IndexOutOfRangeException>(() => a.AsTensorSpan(3, 3).Slice(0..1, 0..1)[0, 1]);
+            Assert.Throws<IndexOutOfRangeException>(() => a.AsTensorSpan([3, 3]).Slice(0..1, 0..1)[0, 1]);
             slice = [1];
             results = new int[1];
             sp.FlattenTo(results);
@@ -1087,7 +1085,7 @@ public static void ReadOnlyTensorSpanSliceTest()
             }
 
             int[] numbers = [.. Enumerable.Range(0, 27)];
-            spanInt = numbers.AsTensorSpan(3, 3, 3);
+            spanInt = numbers.AsTensorSpan([3, 3, 3]);
             sp = spanInt.Slice(1..2, 1..2, 1..2);
             Assert.Equal(13, sp[0, 0, 0]);
             slice = [13];
@@ -1122,7 +1120,7 @@ public static void ReadOnlyTensorSpanSliceTest()
             }
 
             numbers = [.. Enumerable.Range(0, 16)];
-            spanInt = numbers.AsTensorSpan(2, 2, 2, 2);
+            spanInt = numbers.AsTensorSpan([2, 2, 2, 2]);
             sp = spanInt.Slice(1..2, 0..2, 1..2, 0..2);
             Assert.Equal(10, sp[0, 0, 0, 0]);
             Assert.Equal(11, sp[0, 0, 0, 1]);
@@ -1144,7 +1142,7 @@ public static void ReadOnlyTensorSpanSliceTest()
         public static void LongArrayAsReadOnlyTensorSpan()
         {
             long[] b = { 91, -92, 93, 94, -95 };
-            ReadOnlyTensorSpan<long> spanLong = b.AsTensorSpan(5);
+            ReadOnlyTensorSpan<long> spanLong = b.AsTensorSpan([5]);
             Assert.Equal(91, spanLong[0]);
             Assert.Equal(-92, spanLong[1]);
             Assert.Equal(93, spanLong[2]);
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs
index 0d0fc167b6bfcd..b4616cd4f0d77d 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs
@@ -4,7 +4,7 @@
 using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
+using System.Linq.Expressions;
 using System.Runtime.InteropServices;
 using Xunit;
 
@@ -35,61 +35,61 @@ private static nint CalculateTotalLength(ReadOnlySpan<nint> lengths)
             return totalLength;
         }
 
-        public delegate void TensorPrimitivesSpanInSpanOut<TIn, TOut>(ReadOnlySpan<TIn> input, Span<TOut> output);
+        public delegate TOut TensorPrimitivesSpanInSpanOut<TIn, TOut>(TIn input);
         public delegate ref readonly TensorSpan<TOut> TensorSpanInSpanOut<TIn, TOut>(scoped in ReadOnlyTensorSpan<TIn> input, in TensorSpan<TOut> destination);
 
         public static IEnumerable<object[]> SpanInSpanOutData()
         {
-            yield return Create<float, float>(TensorPrimitives.Abs, Tensor.Abs);
-            yield return Create<float, float>(TensorPrimitives.Acos, Tensor.Acos);
-            yield return Create<float, float>(TensorPrimitives.Acosh, Tensor.Acosh);
-            yield return Create<float, float>(TensorPrimitives.AcosPi, Tensor.AcosPi);
-            yield return Create<float, float>(TensorPrimitives.Asin, Tensor.Asin);
-            yield return Create<float, float>(TensorPrimitives.Asinh, Tensor.Asinh);
-            yield return Create<float, float>(TensorPrimitives.AsinPi, Tensor.AsinPi);
-            yield return Create<float, float>(TensorPrimitives.Atan, Tensor.Atan);
-            yield return Create<float, float>(TensorPrimitives.Atanh, Tensor.Atanh);
-            yield return Create<float, float>(TensorPrimitives.AtanPi, Tensor.AtanPi);
-            yield return Create<float, float>(TensorPrimitives.Cbrt, Tensor.Cbrt);
-            yield return Create<float, float>(TensorPrimitives.Ceiling, Tensor.Ceiling);
-            yield return Create<float, float>(TensorPrimitives.Cos, Tensor.Cos);
-            yield return Create<float, float>(TensorPrimitives.Cosh, Tensor.Cosh);
-            yield return Create<float, float>(TensorPrimitives.CosPi, Tensor.CosPi);
-            yield return Create<float, float>(TensorPrimitives.DegreesToRadians, Tensor.DegreesToRadians);
-            yield return Create<float, float>(TensorPrimitives.Exp, Tensor.Exp);
-            yield return Create<float, float>(TensorPrimitives.Exp10, Tensor.Exp10);
-            yield return Create<float, float>(TensorPrimitives.Exp10M1, Tensor.Exp10M1);
-            yield return Create<float, float>(TensorPrimitives.Exp2, Tensor.Exp2);
-            yield return Create<float, float>(TensorPrimitives.Exp2M1, Tensor.Exp2M1);
-            yield return Create<float, float>(TensorPrimitives.ExpM1, Tensor.ExpM1);
-            yield return Create<float, float>(TensorPrimitives.Floor, Tensor.Floor);
-            yield return Create<int, int>(TensorPrimitives.LeadingZeroCount, Tensor.LeadingZeroCount);
-            yield return Create<float, float>(TensorPrimitives.Log, Tensor.Log);
-            yield return Create<float, float>(TensorPrimitives.Log10, Tensor.Log10);
-            yield return Create<float, float>(TensorPrimitives.Log10P1, Tensor.Log10P1);
-            yield return Create<float, float>(TensorPrimitives.Log2, Tensor.Log2);
-            yield return Create<float, float>(TensorPrimitives.Log2P1, Tensor.Log2P1);
-            yield return Create<float, float>(TensorPrimitives.LogP1, Tensor.LogP1);
-            yield return Create<float, float>(TensorPrimitives.Negate, Tensor.Negate);
-            yield return Create<float, float>(TensorPrimitives.OnesComplement, Tensor.OnesComplement);
-            yield return Create<int, int>(TensorPrimitives.PopCount, Tensor.PopCount);
-            yield return Create<float, float>(TensorPrimitives.RadiansToDegrees, Tensor.RadiansToDegrees);
-            yield return Create<float, float>(TensorPrimitives.Reciprocal, Tensor.Reciprocal);
-            yield return Create<float, float>(TensorPrimitives.Round, Tensor.Round);
-            yield return Create<float, float>(TensorPrimitives.Sigmoid, Tensor.Sigmoid);
-            yield return Create<float, float>(TensorPrimitives.Sin, Tensor.Sin);
-            yield return Create<float, float>(TensorPrimitives.Sinh, Tensor.Sinh);
-            yield return Create<float, float>(TensorPrimitives.SinPi, Tensor.SinPi);
-            yield return Create<float, float>(TensorPrimitives.SoftMax, Tensor.SoftMax);
-            yield return Create<float, float>(TensorPrimitives.Sqrt, Tensor.Sqrt);
-            yield return Create<float, float>(TensorPrimitives.Tan, Tensor.Tan);
-            yield return Create<float, float>(TensorPrimitives.Tanh, Tensor.Tanh);
-            yield return Create<float, float>(TensorPrimitives.TanPi, Tensor.TanPi);
-            yield return Create<float, float>(TensorPrimitives.Truncate, Tensor.Truncate);
-            yield return Create<float, int>(TensorPrimitives.ILogB, Tensor.ILogB);
-            yield return Create<float, int>(TensorPrimitives.ConvertChecked, Tensor.ConvertChecked);
-            yield return Create<float, int>(TensorPrimitives.ConvertSaturating, Tensor.ConvertSaturating);
-            yield return Create<float, int>(TensorPrimitives.ConvertTruncating, Tensor.ConvertTruncating);
+            yield return Create<float, float>(float.Abs, Tensor.Abs);
+            yield return Create<float, float>(float.Acos, Tensor.Acos);
+            yield return Create<float, float>(float.Acosh, Tensor.Acosh);
+            yield return Create<float, float>(float.AcosPi, Tensor.AcosPi);
+            yield return Create<float, float>(float.Asin, Tensor.Asin);
+            yield return Create<float, float>(float.Asinh, Tensor.Asinh);
+            yield return Create<float, float>(float.AsinPi, Tensor.AsinPi);
+            yield return Create<float, float>(float.Atan, Tensor.Atan);
+            yield return Create<float, float>(float.Atanh, Tensor.Atanh);
+            yield return Create<float, float>(float.AtanPi, Tensor.AtanPi);
+            yield return Create<float, float>(float.Cbrt, Tensor.Cbrt);
+            yield return Create<float, float>(float.Ceiling, Tensor.Ceiling);
+            yield return Create<float, float>(float.Cos, Tensor.Cos);
+            yield return Create<float, float>(float.Cosh, Tensor.Cosh);
+            yield return Create<float, float>(float.CosPi, Tensor.CosPi);
+            yield return Create<float, float>(float.DegreesToRadians, Tensor.DegreesToRadians);
+            yield return Create<float, float>(float.Exp, Tensor.Exp);
+            yield return Create<float, float>(float.Exp10, Tensor.Exp10);
+            yield return Create<float, float>(float.Exp10M1, Tensor.Exp10M1);
+            yield return Create<float, float>(float.Exp2, Tensor.Exp2);
+            yield return Create<float, float>(float.Exp2M1, Tensor.Exp2M1);
+            yield return Create<float, float>(float.ExpM1, Tensor.ExpM1);
+            yield return Create<float, float>(float.Floor, Tensor.Floor);
+            yield return Create<int, int>(int.LeadingZeroCount, Tensor.LeadingZeroCount);
+            yield return Create<float, float>(float.Log, Tensor.Log);
+            yield return Create<float, float>(float.Log10, Tensor.Log10);
+            yield return Create<float, float>(float.Log10P1, Tensor.Log10P1);
+            yield return Create<float, float>(float.Log2, Tensor.Log2);
+            yield return Create<float, float>(float.Log2P1, Tensor.Log2P1);
+            yield return Create<float, float>(float.LogP1, Tensor.LogP1);
+            yield return Create<float, float>(x => -x, Tensor.Negate);
+            yield return Create<int, int>(x => ~x, Tensor.OnesComplement);
+            yield return Create<int, int>(int.PopCount, Tensor.PopCount);
+            yield return Create<float, float>(float.RadiansToDegrees, Tensor.RadiansToDegrees);
+            yield return Create<float, float>(f => 1 / f, Tensor.Reciprocal);
+            yield return Create<float, float>(float.Round, Tensor.Round);
+            //yield return Create<float, float>(float.Sigmoid, Tensor.Sigmoid);
+            yield return Create<float, float>(float.Sin, Tensor.Sin);
+            yield return Create<float, float>(float.Sinh, Tensor.Sinh);
+            yield return Create<float, float>(float.SinPi, Tensor.SinPi);
+            //yield return Create<float, float>(float.SoftMax, Tensor.SoftMax);
+            yield return Create<float, float>(float.Sqrt, Tensor.Sqrt);
+            yield return Create<float, float>(float.Tan, Tensor.Tan);
+            yield return Create<float, float>(float.Tanh, Tensor.Tanh);
+            yield return Create<float, float>(float.TanPi, Tensor.TanPi);
+            yield return Create<float, float>(float.Truncate, Tensor.Truncate);
+            yield return Create<float, int>(float.ILogB, Tensor.ILogB);
+            yield return Create<float, int>(x => Expression.Lambda<Func<int>>(Expression.ConvertChecked(Expression.Constant(x), typeof(int))).Compile()(), Tensor.ConvertChecked);
+            yield return Create<float, int>(x => (int)x, Tensor.ConvertSaturating);
+            yield return Create<float, int>(x => (int)MathF.Truncate(x), Tensor.ConvertTruncating);
 
             static object[] Create<TIn, TOut>(TensorPrimitivesSpanInSpanOut<TIn, TOut> tensorPrimitivesMethod, TensorSpanInSpanOut<TIn, TOut> tensorOperation)
                 => new object[] { tensorPrimitivesMethod, tensorOperation };
@@ -106,26 +106,21 @@ public void TensorExtensionsSpanInSpanOut<TIn, TOut>(TensorPrimitivesSpanInSpanO
 
                 TIn[] data = new TIn[length];
                 TOut[] data2 = new TOut[length];
-                TOut[] expectedOutput = new TOut[length];
 
                 FillTensor<TIn>(data);
                 TensorSpan<TIn> x = Tensor.Create<TIn>(data, tensorLength, []);
                 TensorSpan<TOut> destination = Tensor.Create<TOut>(data2, tensorLength, []);
-                tensorPrimitivesOperation((ReadOnlySpan<TIn>)data, expectedOutput);
                 TensorSpan<TOut> tensorResults = tensorOperation(x, destination);
 
                 Assert.Equal(tensorLength, tensorResults.Lengths);
                 nint[] startingIndex = new nint[tensorLength.Length];
 
                 // the "Return" value
-                ReadOnlySpan<TOut> span = MemoryMarshal.CreateSpan(ref tensorResults[startingIndex], (int)length);
-                // the "destination" value
-                ReadOnlySpan<TOut> destSpan = MemoryMarshal.CreateSpan(ref destination[startingIndex], (int)length);
+                ReadOnlySpan<TOut> span = MemoryMarshal.CreateSpan(ref tensorResults.GetPinnableReference(), (int)length);
 
                 for (int i = 0; i < data.Length; i++)
                 {
-                    Assert.Equal(expectedOutput[i], span[i]);
-                    Assert.Equal(expectedOutput[i], destSpan[i]);
+                    Assert.Equal(tensorPrimitivesOperation(data[i]), span[i]);
                 }
 
                 // Now test if the source is sliced to be smaller then the destination that the destination is also sliced
@@ -134,79 +129,23 @@ public void TensorExtensionsSpanInSpanOut<TIn, TOut>(TensorPrimitivesSpanInSpanO
                 nint sliceFlattenedLength = CalculateTotalLength(Helpers.TensorSliceShapes[index]);
                 x = x.Slice(sliceLengths);
                 TIn[] sliceData = new TIn[sliceFlattenedLength];
-                x.FlattenTo(sliceData);
-                expectedOutput = new TOut[sliceFlattenedLength];
-
-                if (TensorHelpers.IsContiguousAndDense<TIn>(x))
-                {
-                    tensorPrimitivesOperation((ReadOnlySpan<TIn>)sliceData, expectedOutput);
-                }
-                else
-                {
-                    int rowLength = (int)Helpers.TensorSliceShapes[index][^1];
-                    for (int i = 0; i < sliceData.Length; i+= rowLength)
-                    {
-                        tensorPrimitivesOperation(((ReadOnlySpan<TIn>)sliceData).Slice(i, rowLength), ((Span<TOut>)expectedOutput).Slice(i, rowLength));
-                    }
-
-                }
-
-                tensorResults = tensorOperation(x, destination);
-
-                // tensorResults lengths will still be the original tensorLength and not equal to the sliced length since that happened internally/automatically
-                Assert.Equal(tensorLength, tensorResults.Lengths);
-
-                TensorSpan<TOut>.Enumerator destEnum = destination.Slice(sliceLengths).GetEnumerator();
-                TensorSpan<TOut>.Enumerator tensorResultsEnum = tensorResults.Slice(sliceLengths).GetEnumerator();
-                bool destEnumMove;
-                bool tensorResultsEnumMove;
-
-                for (int i = 0; i < expectedOutput.Length; i++)
-                {
-                    destEnumMove = destEnum.MoveNext();
-                    tensorResultsEnumMove = tensorResultsEnum.MoveNext();
-
-                    Assert.True(destEnumMove);
-                    Assert.True(tensorResultsEnumMove);
-                    Assert.Equal(expectedOutput[i], destEnum.Current);
-                    Assert.Equal(expectedOutput[i], tensorResultsEnum.Current);
-                }
 
                 // Now test if the source and destination are sliced (so neither is continuous) it works correctly.
                 destination = destination.Slice(sliceLengths);
                 x.FlattenTo(sliceData);
-                expectedOutput = new TOut[sliceFlattenedLength];
-
-                if (TensorHelpers.IsContiguousAndDense<TIn>(x))
-                {
-                    tensorPrimitivesOperation((ReadOnlySpan<TIn>)sliceData, expectedOutput);
-                }
-                else
-                {
-                    int rowLength = (int)Helpers.TensorSliceShapes[index][^1];
-                    for (int i = 0; i < sliceData.Length; i += rowLength)
-                    {
-                        tensorPrimitivesOperation(((ReadOnlySpan<TIn>)sliceData).Slice(i, rowLength), ((Span<TOut>)expectedOutput).Slice(i, rowLength));
-                    }
-
-                }
 
                 tensorResults = tensorOperation(x, destination);
 
                 Assert.Equal(Helpers.TensorSliceShapes[index], tensorResults.Lengths);
 
-                destEnum = destination.GetEnumerator();
-                tensorResultsEnum = tensorResults.GetEnumerator();
-
-                for (int i = 0; i < expectedOutput.Length; i++)
+                TensorSpan<TOut>.Enumerator tensorResultsEnum = tensorResults.GetEnumerator();
+                bool tensorResultsEnumMove;
+                for (int i = 0; i < sliceData.Length; i++)
                 {
-                    destEnumMove = destEnum.MoveNext();
                     tensorResultsEnumMove = tensorResultsEnum.MoveNext();
 
-                    Assert.True(destEnumMove);
                     Assert.True(tensorResultsEnumMove);
-                    Assert.Equal(expectedOutput[i], destEnum.Current);
-                    Assert.Equal(expectedOutput[i], tensorResultsEnum.Current);
+                    Assert.Equal(tensorPrimitivesOperation(sliceData[i]), tensorResultsEnum.Current);
                 }
             });
         }
@@ -221,9 +160,33 @@ public static IEnumerable<object[]> SpanInFloatOutData()
             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);
+            yield return Create<float>(x =>
+            {
+                float sum = 0;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    sum += x[i] * x[i];
+                }
+                return float.Sqrt(sum);
+            }, Tensor.Norm);
+            yield return Create<float>(x =>
+            {
+                float sum = 1;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    sum *= x[i];
+                }
+                return sum;
+            }, Tensor.Product);
+            yield return Create<float>(x =>
+            {
+                float sum = 0;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    sum += x[i];
+                }
+                return sum;
+            }, Tensor.Sum);
 
             static object[] Create<T>(TensorPrimitivesSpanInTOut<T> tensorPrimitivesMethod, TensorSpanInTOut<T> tensorOperation)
                 => new object[] { tensorPrimitivesMethod, tensorOperation };
@@ -269,21 +232,21 @@ public void TensorExtensionsSpanInTOut<T>(TensorPrimitivesSpanInTOut<T> tensorPr
             });
         }
 
-        public delegate void TensorPrimitivesTwoSpanInSpanOut<T>(ReadOnlySpan<T> input, ReadOnlySpan<T> inputTwo, Span<T> output);
+        public delegate T TensorPrimitivesTwoSpanInSpanOut<T>(T input, T inputTwo);
         public delegate ref readonly TensorSpan<T> TensorTwoSpanInSpanOut<T>(scoped in ReadOnlyTensorSpan<T> input, scoped in ReadOnlyTensorSpan<T> inputTwo, in TensorSpan<T> destination);
         public delegate ref readonly TensorSpan<T> TensorTwoSpanInSpanOutInPlace<T>(in TensorSpan<T> input, scoped in ReadOnlyTensorSpan<T> inputTwo);
         public static IEnumerable<object[]> TwoSpanInSpanOutData()
         {
-            yield return Create<float>(TensorPrimitives.Add, Tensor.Add);
-            yield return Create<float>(TensorPrimitives.Atan2, Tensor.Atan2);
-            yield return Create<float>(TensorPrimitives.Atan2Pi, Tensor.Atan2Pi);
-            yield return Create<float>(TensorPrimitives.CopySign, Tensor.CopySign);
-            yield return Create<float>(TensorPrimitives.Divide, Tensor.Divide);
-            yield return Create<float>(TensorPrimitives.Hypot, Tensor.Hypot);
-            yield return Create<float>(TensorPrimitives.Ieee754Remainder, Tensor.Ieee754Remainder);
-            yield return Create<float>(TensorPrimitives.Multiply, Tensor.Multiply);
-            yield return Create<float>(TensorPrimitives.Pow, Tensor.Pow);
-            yield return Create<float>(TensorPrimitives.Subtract, Tensor.Subtract);
+            yield return Create<float>((x, y) => x + y, Tensor.Add);
+            yield return Create<float>((x, y) => float.Atan2(x, y), Tensor.Atan2);
+            yield return Create<float>((x, y) => float.Atan2Pi(x, y), Tensor.Atan2Pi);
+            yield return Create<float>((x, y) => float.CopySign(x, y), Tensor.CopySign);
+            yield return Create<float>((x, y) => x / y, Tensor.Divide);
+            yield return Create<float>((x, y) => float.Hypot(x, y), Tensor.Hypot);
+            yield return Create<float>((x, y) => float.Ieee754Remainder(x, y), Tensor.Ieee754Remainder);
+            yield return Create<float>((x, y) => x * y, Tensor.Multiply);
+            yield return Create<float>((x, y) => float.Pow(x, y), Tensor.Pow);
+            yield return Create<float>((x, y) => x - y, Tensor.Subtract);
 
             static object[] Create<T>(TensorPrimitivesTwoSpanInSpanOut<T> tensorPrimitivesMethod, TensorTwoSpanInSpanOut<T> tensorOperation)
                 => new object[] { tensorPrimitivesMethod, tensorOperation };
@@ -309,162 +272,67 @@ public void TensorExtensionsTwoSpanInSpanOut<T>(TensorPrimitivesTwoSpanInSpanOut
                 TensorSpan<T> x = Tensor.Create<T>(data1, tensorLengths, []);
                 TensorSpan<T> y = Tensor.Create<T>(data2, tensorLengths, []);
                 TensorSpan<T> destination = Tensor.Create<T>(destData, tensorLengths, []);
-                tensorPrimitivesOperation((ReadOnlySpan<T>)data1, data2, expectedOutput);
                 TensorSpan<T> results = tensorOperation(x, y, destination);
 
                 Assert.Equal(tensorLengths, results.Lengths);
                 nint[] startingIndex = new nint[tensorLengths.Length];
                 // the "Return" value
-                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref results[startingIndex], (int)length);
-                // the "destination" value
-                ReadOnlySpan<T> destSpan = MemoryMarshal.CreateSpan(ref destination[startingIndex], (int)length);
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref results.GetPinnableReference(), (int)length);
 
                 for (int i = 0; i < data1.Length; i++)
                 {
-                    Assert.Equal(expectedOutput[i], span[i]);
-                    Assert.Equal(expectedOutput[i], destSpan[i]);
+                    Assert.Equal(tensorPrimitivesOperation(data1[i], data2[i]), span[i]);
                 }
 
-                // Now test when both sources are exact sizes but destination is too large and gets sliced internally.
-                nint[] tempLengths = tensorLengths.Select(i => i + 1).ToArray();
-                T[] tempDestData = new T[CalculateTotalLength(tempLengths)];
-                destination = Tensor.Create<T>(tempDestData, tempLengths, []);
-                results = tensorOperation(x, y, destination);
-
-                // Since the slice was internal the result lengths will be the extra large size.
-                Assert.Equal(tempLengths, results.Lengths);
-                startingIndex = new nint[tensorLengths.Length];
-
-                TensorSpan<T>.Enumerator destEnum = destination.Slice(tensorLengths).GetEnumerator();
-                TensorSpan<T>.Enumerator tensorResultsEnum = results.Slice(tensorLengths).GetEnumerator();
-                bool destEnumMove;
-                bool tensorResultsEnumMove;
-
-                for (int i = 0; i < expectedOutput.Length; i++)
-                {
-                    destEnumMove = destEnum.MoveNext();
-                    tensorResultsEnumMove = tensorResultsEnum.MoveNext();
-
-                    Assert.True(destEnumMove);
-                    Assert.True(tensorResultsEnumMove);
-                    Assert.Equal(expectedOutput[i], destEnum.Current);
-                    Assert.Equal(expectedOutput[i], tensorResultsEnum.Current);
-                }
 
                 // Now test if the first source is sliced to be smaller than the second (but is broadcast compatible) that broadcasting happens).
                 int rowLength = (int)Helpers.TensorSliceShapesForBroadcast[index][^1];
 
                 NRange[] sliceLengths = Helpers.TensorSliceShapesForBroadcast[index].Select(i => new NRange(0, i)).ToArray();
                 nint sliceFlattenedLength = CalculateTotalLength(Helpers.TensorSliceShapesForBroadcast[index]);
-                destination = destination.Slice(tensorLengths);
+                //destination = destination.Slice(sliceLengths);
                 x.Slice(sliceLengths).BroadcastTo(x);
                 x.FlattenTo(data1);
 
-                if (TensorHelpers.IsContiguousAndDense<T>(x.Slice(sliceLengths)) && TensorHelpers.IsContiguousAndDense<T>(y))
-                {
-                    tensorPrimitivesOperation((ReadOnlySpan<T>)data1, data2, expectedOutput);
-                }
-                else
-                {
-                    for (int i = 0; i < data1.Length; i += rowLength)
-                    {
-                        tensorPrimitivesOperation(((ReadOnlySpan<T>)data1).Slice(i, rowLength), ((ReadOnlySpan<T>)data2).Slice(i, rowLength), ((Span<T>)expectedOutput).Slice(i, rowLength));
-                    }
-
-                }
-
                 results = tensorOperation(x.Slice(sliceLengths), y, destination);
 
                 // results lengths will still be the original tensorLength
                 Assert.Equal(tensorLengths, results.Lengths);
 
-                destEnum = destination.GetEnumerator();
-                tensorResultsEnum = results.GetEnumerator();
+                TensorSpan<T>.Enumerator tensorResultsEnum = results.GetEnumerator();
+                TensorSpan<T>.Enumerator xEnum = x.GetEnumerator();
+                TensorSpan<T>.Enumerator yEnum = y.GetEnumerator();
+                bool tensorResultsEnumMove;
 
-                for (int i = 0; i < expectedOutput.Length; i++)
+                for (int i = 0; i < results.FlattenedLength; i++)
                 {
-                    destEnumMove = destEnum.MoveNext();
                     tensorResultsEnumMove = tensorResultsEnum.MoveNext();
-
-                    Assert.True(destEnumMove);
+                    xEnum.MoveNext();
+                    yEnum.MoveNext();
                     Assert.True(tensorResultsEnumMove);
-                    Assert.Equal(expectedOutput[i], destEnum.Current);
-                    Assert.Equal(expectedOutput[i], tensorResultsEnum.Current);
+
+                    Assert.Equal(tensorPrimitivesOperation(xEnum.Current, yEnum.Current), tensorResultsEnum.Current);
                 }
 
                 // Now test if the second source is sliced to be smaller than the first (but is broadcast compatible) that broadcasting happens).
                 y.Slice(sliceLengths).BroadcastTo(y);
                 y.FlattenTo(data2);
 
-                if (TensorHelpers.IsContiguousAndDense<T>(x) && TensorHelpers.IsContiguousAndDense<T>(y.Slice(sliceLengths)))
-                {
-                    tensorPrimitivesOperation((ReadOnlySpan<T>)data1, data2, expectedOutput);
-                }
-                else
-                {
-                    for (int i = 0; i < data2.Length; i += rowLength)
-                    {
-                        tensorPrimitivesOperation(((ReadOnlySpan<T>)data1).Slice(i, rowLength), ((ReadOnlySpan<T>)data2).Slice(i, rowLength), ((Span<T>)expectedOutput).Slice(i, rowLength));
-                    }
-
-                }
-
                 results = tensorOperation(x, y.Slice(sliceLengths), destination);
 
                 // results lengths will still be the original tensorLength
                 Assert.Equal(tensorLengths, results.Lengths);
 
-                destEnum = destination.GetEnumerator();
                 tensorResultsEnum = results.GetEnumerator();
-
-                for (int i = 0; i < expectedOutput.Length; i++)
-                {
-                    destEnumMove = destEnum.MoveNext();
-                    tensorResultsEnumMove = tensorResultsEnum.MoveNext();
-
-                    Assert.True(destEnumMove);
-                    Assert.True(tensorResultsEnumMove);
-                    Assert.Equal(expectedOutput[i], destEnum.Current);
-                    Assert.Equal(expectedOutput[i], tensorResultsEnum.Current);
-                }
-
-                // Now test if both sources are sliced to be smaller than the destination that the destination will be sliced automatically
-                T[] sliceData1 = new T[sliceFlattenedLength];
-                T[] sliceData2 = new T[sliceFlattenedLength];
-                expectedOutput = new T[sliceFlattenedLength];
-
-                x.Slice(sliceLengths).FlattenTo(sliceData1);
-                y.Slice(sliceLengths).FlattenTo(sliceData2);
-
-                if (TensorHelpers.IsContiguousAndDense<T>(x.Slice(sliceLengths)) && TensorHelpers.IsContiguousAndDense<T>(y.Slice(sliceLengths)))
-                {
-                    tensorPrimitivesOperation((ReadOnlySpan<T>)sliceData1, sliceData2, expectedOutput);
-                }
-                else
-                {
-                    for (int i = 0; i < sliceData1.Length; i += rowLength)
-                    {
-                        tensorPrimitivesOperation(((ReadOnlySpan<T>)sliceData1).Slice(i, rowLength), ((ReadOnlySpan<T>)sliceData2).Slice(i, rowLength), ((Span<T>)expectedOutput).Slice(i, rowLength));
-                    }
-
-                }
-
-                results = tensorOperation(x.Slice(sliceLengths), y.Slice(sliceLengths), destination);
-
-                Assert.Equal(tensorLengths, results.Lengths);
-
-                destEnum = destination.Slice(sliceLengths).GetEnumerator();
-                tensorResultsEnum = results.Slice(sliceLengths).GetEnumerator();
-
-                for (int i = 0; i < expectedOutput.Length; i++)
+                xEnum = x.GetEnumerator();
+                yEnum = y.GetEnumerator();
+                for (int i = 0; i < results.FlattenedLength; i++)
                 {
-                    destEnumMove = destEnum.MoveNext();
                     tensorResultsEnumMove = tensorResultsEnum.MoveNext();
-
-                    Assert.True(destEnumMove);
+                    xEnum.MoveNext();
+                    yEnum.MoveNext();
                     Assert.True(tensorResultsEnumMove);
-                    Assert.Equal(expectedOutput[i], destEnum.Current);
-                    Assert.Equal(expectedOutput[i], tensorResultsEnum.Current);
+                    Assert.Equal(tensorPrimitivesOperation(xEnum.Current, yEnum.Current), tensorResultsEnum.Current);
                 }
             });
         }
@@ -551,7 +419,7 @@ public static unsafe void TensorSpanSetSliceTests()
             {
                 var ab = new TensorSpan<double>(array: [0d, 1, 2, 3, 0d, 1, 2, 3]);  // [0, 1, 2, 3]
                 var b = ab.Reshape(lengths: new IntPtr[] { 2, 2, 2 });  // [[0, 1], [2, 3]]
-                var c = b.Slice(ranges: new NRange[] { 1.., 1..2, ..1 });  // [[0], [2]]
+                var c = b.Slice(new NRange[] { 1.., 1..2, ..1 });  // [[0], [2]]
                 c.Reshape(lengths: new IntPtr[] { 1, 2, 1 });
             });
 
@@ -775,7 +643,7 @@ public static void TensorSpanSystemArrayConstructorTests()
             Assert.Equal(-93, spanInt[1, 1]);
 
             // Make sure you can't overlap elements using strides
-            Assert.Throws<ArgumentOutOfRangeException>(() =>
+            Assert.Throws<ArgumentException>(() =>
             {
                 var spanInt = new TensorSpan<int>(a, (int[])[], [2, 2], [1, 1]);
             });
@@ -790,34 +658,34 @@ public static void TensorSpanSystemArrayConstructorTests()
             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]);
+            // // TODO: Make sure it works with NIndex
+            // spanInt = new TensorSpan<int>(a, [0, 0], (NIndex[])[1, 1], [2, 2]);
+            // 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]);
+
+            // // TODO: Make sure it works with NIndex
+            // spanInt = new TensorSpan<int>(a, [0, 0], (NIndex[])[^1, ^1], [2, 2]);
+            // 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 exception is thrown if lengths and strides would let you go past the end of the array
-            Assert.Throws<ArgumentException>(() => new TensorSpan<double>(new double[0], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 }));
-            Assert.Throws<ArgumentException>(() => new TensorSpan<double>(new double[1], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 }));
-            Assert.Throws<ArgumentException>(() => new TensorSpan<double>(new double[2], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 2 }));
+            Assert.Throws<ArgumentOutOfRangeException>(() => new TensorSpan<double>(new double[0], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 }));
+            Assert.Throws<ArgumentOutOfRangeException>(() => new TensorSpan<double>(new double[1], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 }));
+            Assert.Throws<ArgumentOutOfRangeException>(() => new TensorSpan<double>(new double[2], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 2 }));
 
             // Make sure basic T[] constructor works
             int[] a = { 91, 92, -93, 94 };
@@ -843,7 +711,7 @@ public static void TensorSpanArrayConstructorTests()
             Assert.Equal(1, spanInt.Rank);
             Assert.Equal(0, spanInt.Lengths[0]);
             Assert.Equal(0, spanInt.FlattenedLength);
-            Assert.Equal(0, spanInt.Strides[0]);
+            Assert.Equal(1, spanInt.Strides[0]);
             // Make sure it still throws on index 0
             Assert.Throws<IndexOutOfRangeException>(() => {
                 var spanInt = new TensorSpan<int>(b);
@@ -859,7 +727,7 @@ public static void TensorSpanArrayConstructorTests()
             Assert.Equal(0, spanInt.Strides[0]);
 
             // Make sure 2D array works
-            spanInt = new TensorSpan<int>(a, new Index(0), [2, 2], default);
+            spanInt = new TensorSpan<int>(a, 0, [2, 2], default);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(2, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -869,24 +737,24 @@ public static void TensorSpanArrayConstructorTests()
             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);
+            spanInt = new TensorSpan<int>(a, 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 spanInt = new TensorSpan<int>(a, 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 spanInt = new TensorSpan<int>(a, 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);
+            spanInt = new TensorSpan<int>(a, 1, [1, 2], default);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(1, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -894,7 +762,7 @@ public static void TensorSpanArrayConstructorTests()
             Assert.Equal(-93, spanInt[0, 1]);
 
             // Make sure Index offset works correctly
-            spanInt = new TensorSpan<int>(a, new Index(2), [1, 2], default);
+            spanInt = new TensorSpan<int>(a, 2, [1, 2], default);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(1, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -902,12 +770,12 @@ public static void TensorSpanArrayConstructorTests()
             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);
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
+                var spanInt = new TensorSpan<int>(a, 3, [1, 2], default);
             });
 
             // Make sure 2D array works with basic strides
-            spanInt = new TensorSpan<int>(a, new Index(0), [2, 2], [2, 1]);
+            spanInt = new TensorSpan<int>(a, 0, [2, 2], [2, 1]);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(2, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -917,7 +785,7 @@ public static void TensorSpanArrayConstructorTests()
             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]);
+            spanInt = new TensorSpan<int>(a, 0, [2, 2], [0, 1]);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(2, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -927,7 +795,7 @@ public static void TensorSpanArrayConstructorTests()
             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]);
+            spanInt = new TensorSpan<int>(a, 2, [2, 2], [0, 1]);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(2, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -937,7 +805,7 @@ public static void TensorSpanArrayConstructorTests()
             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]);
+            spanInt = new TensorSpan<int>(a, 3, [2, 2], [0, 0]);
             Assert.Equal(2, spanInt.Rank);
             Assert.Equal(2, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -948,18 +816,18 @@ public static void TensorSpanArrayConstructorTests()
 
             // Make sure strides can't be negative
             Assert.Throws<ArgumentOutOfRangeException>(() => {
-                var spanInt = new TensorSpan<int>(a, new Index(3), [1, 2], [-1, 0]);
+                var spanInt = new TensorSpan<int>(a, 3, [1, 2], [-1, 0]);
             });
             Assert.Throws<ArgumentOutOfRangeException>(() => {
-                var spanInt = new TensorSpan<int>(a, new Index(3), [1, 2], [0, -1]);
+                var spanInt = new TensorSpan<int>(a, 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], []);
+                var spanInt = new TensorSpan<int>(a, 3, [-1, 2], []);
             });
             Assert.Throws<ArgumentOutOfRangeException>(() => {
-                var spanInt = new TensorSpan<int>(a, new Index(3), [1, -2], []);
+                var spanInt = new TensorSpan<int>(a, 3, [1, -2], []);
             });
 
             // Make sure 2D array works with strides to hit element 0,0,2,2
@@ -973,7 +841,7 @@ public static void TensorSpanArrayConstructorTests()
             Assert.Equal(-93, spanInt[1, 1]);
 
             // Make sure you can't overlap elements using strides
-            Assert.Throws<ArgumentOutOfRangeException>(() => {
+            Assert.Throws<ArgumentException>(() => {
                 var spanInt = new TensorSpan<int>(a, 0, [2, 2], [1, 1]);
             });
         }
@@ -995,12 +863,12 @@ public static void TensorSpanSpanConstructorTests()
             // 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.Rank);
+            Assert.Equal(0, spanInt.Lengths.Length);
             Assert.Equal(0, spanInt.FlattenedLength);
-            Assert.Equal(0, spanInt.Strides[0]);
+            Assert.Equal(0, spanInt.Strides.Length);
             // Make sure it still throws on index 0
-            Assert.Throws<IndexOutOfRangeException>(() => {
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
                 Span<int> b = [];
                 var spanInt = new TensorSpan<int>(b);
                 var x = spanInt[0];
@@ -1052,7 +920,7 @@ public static void TensorSpanSpanConstructorTests()
             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>(() => {
+            Assert.Throws<ArgumentOutOfRangeException>(() => {
                 Span<int> a = [91, 92, -93, 94];
                 var spanInt = new TensorSpan<int>(a.Slice(3), [1, 2], default);
             });
@@ -1128,7 +996,7 @@ public static void TensorSpanSpanConstructorTests()
             Assert.Equal(-93, spanInt[1, 1]);
 
             // Make sure you can't overlap elements using strides
-            Assert.Throws<ArgumentOutOfRangeException>(() => {
+            Assert.Throws<ArgumentException>(() => {
                 Span<int> a = [91, 92, -93, 94];
                 var spanInt = new TensorSpan<int>(a, [2, 2], [1, 1]);
             });
@@ -1157,12 +1025,12 @@ public static unsafe void TensorSpanPointerConstructorTests()
             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.Rank);
+                Assert.Equal(0, spanInt.Lengths.Length);
                 Assert.Equal(0, spanInt.FlattenedLength);
-                Assert.Equal(0, spanInt.Strides[0]);
+                Assert.Equal(0, spanInt.Strides.Length);
                 // Make sure it still throws on index 0
-                Assert.Throws<IndexOutOfRangeException>(() =>
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
                 {
                     Span<int> b = [];
                     fixed (int* p = b)
@@ -1229,7 +1097,7 @@ public static unsafe void TensorSpanPointerConstructorTests()
                 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>(() =>
+                Assert.Throws<ArgumentOutOfRangeException>(() =>
                 {
                     Span<int> a = [91, 92, -93, 94];
                     fixed (int* p = a)
@@ -1335,7 +1203,7 @@ public static unsafe void TensorSpanPointerConstructorTests()
                 Assert.Equal(-93, spanInt[1, 1]);
 
                 // Make sure you can't overlap elements using strides
-                Assert.Throws<ArgumentOutOfRangeException>(() =>
+                Assert.Throws<ArgumentException>(() =>
                 {
                     Span<int> a = [91, 92, -93, 94];
                     fixed (int* p = a)
@@ -1351,7 +1219,7 @@ public static void TensorSpanLargeDimensionsTests()
         {
             int[] a = { 91, 92, -93, 94, 95, -96 };
             int[] results = new int[6];
-            TensorSpan<int> spanInt = a.AsTensorSpan(1, 1, 1, 1, 1, 6);
+            TensorSpan<int> spanInt = a.AsTensorSpan([1, 1, 1, 1, 1, 6]);
             Assert.Equal(6, spanInt.Rank);
 
             Assert.Equal(6, spanInt.Lengths.Length);
@@ -1362,11 +1230,11 @@ public static void TensorSpanLargeDimensionsTests()
             Assert.Equal(1, spanInt.Lengths[4]);
             Assert.Equal(6, spanInt.Lengths[5]);
             Assert.Equal(6, spanInt.Strides.Length);
-            Assert.Equal(6, spanInt.Strides[0]);
-            Assert.Equal(6, spanInt.Strides[1]);
-            Assert.Equal(6, spanInt.Strides[2]);
-            Assert.Equal(6, spanInt.Strides[3]);
-            Assert.Equal(6, spanInt.Strides[4]);
+            Assert.Equal(0, spanInt.Strides[0]);
+            Assert.Equal(0, spanInt.Strides[1]);
+            Assert.Equal(0, spanInt.Strides[2]);
+            Assert.Equal(0, spanInt.Strides[3]);
+            Assert.Equal(0, spanInt.Strides[4]);
             Assert.Equal(1, spanInt.Strides[5]);
             Assert.Equal(91, spanInt[0, 0, 0, 0, 0, 0]);
             Assert.Equal(92, spanInt[0, 0, 0, 0, 0, 1]);
@@ -1379,7 +1247,7 @@ public static void TensorSpanLargeDimensionsTests()
 
             a = [91, 92, -93, 94, 95, -96, -91, -92, 93, -94, -95, 96];
             results = new int[12];
-            spanInt = a.AsTensorSpan(1, 2, 2, 1, 1, 3);
+            spanInt = a.AsTensorSpan([1, 2, 2, 1, 1, 3]);
             Assert.Equal(6, spanInt.Lengths.Length);
             Assert.Equal(1, spanInt.Lengths[0]);
             Assert.Equal(2, spanInt.Lengths[1]);
@@ -1388,11 +1256,11 @@ public static void TensorSpanLargeDimensionsTests()
             Assert.Equal(1, spanInt.Lengths[4]);
             Assert.Equal(3, spanInt.Lengths[5]);
             Assert.Equal(6, spanInt.Strides.Length);
-            Assert.Equal(12, spanInt.Strides[0]);
+            Assert.Equal(0, spanInt.Strides[0]);
             Assert.Equal(6, spanInt.Strides[1]);
             Assert.Equal(3, spanInt.Strides[2]);
-            Assert.Equal(3, spanInt.Strides[3]);
-            Assert.Equal(3, spanInt.Strides[4]);
+            Assert.Equal(0, spanInt.Strides[3]);
+            Assert.Equal(0, spanInt.Strides[4]);
             Assert.Equal(1, spanInt.Strides[5]);
             Assert.Equal(91, spanInt[0, 0, 0, 0, 0, 0]);
             Assert.Equal(92, spanInt[0, 0, 0, 0, 0, 1]);
@@ -1415,7 +1283,7 @@ public static void IntArrayAsTensorSpan()
         {
             int[] a = { 91, 92, -93, 94 };
             int[] results = new int[4];
-            TensorSpan<int> spanInt = a.AsTensorSpan(4);
+            TensorSpan<int> spanInt = a.AsTensorSpan([4]);
             Assert.Equal(1, spanInt.Rank);
 
             Assert.Equal(1, spanInt.Lengths.Length);
@@ -1442,7 +1310,7 @@ public static void IntArrayAsTensorSpan()
             a[1] = 92;
             a[2] = -93;
             a[3] = 94;
-            spanInt = a.AsTensorSpan(2, 2);
+            spanInt = a.AsTensorSpan([2, 2]);
             spanInt.FlattenTo(results);
             Assert.Equal(a, results);
             Assert.Equal(2, spanInt.Rank);
@@ -1472,7 +1340,7 @@ public static void IntArrayAsTensorSpan()
         public static void TensorSpanFillTest()
         {
             int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-            TensorSpan<int> spanInt = a.AsTensorSpan(3, 3);
+            TensorSpan<int> spanInt = a.AsTensorSpan([3, 3]);
             spanInt.Fill(-1);
             var enumerator = spanInt.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1495,7 +1363,7 @@ public static void TensorSpanFillTest()
             }
 
             a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-            spanInt = a.AsTensorSpan(9);
+            spanInt = a.AsTensorSpan([9]);
             spanInt.Fill(-1);
             enumerator = spanInt.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1504,7 +1372,7 @@ public static void TensorSpanFillTest()
             }
 
             a = [.. Enumerable.Range(0, 27)];
-            spanInt = a.AsTensorSpan(3,3,3);
+            spanInt = a.AsTensorSpan([3,3,3]);
             spanInt.Fill(-1);
             enumerator = spanInt.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1513,7 +1381,7 @@ public static void TensorSpanFillTest()
             }
 
             a = [.. Enumerable.Range(0, 12)];
-            spanInt = a.AsTensorSpan(3, 2, 2);
+            spanInt = a.AsTensorSpan([3, 2, 2]);
             spanInt.Fill(-1);
             enumerator = spanInt.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1522,7 +1390,7 @@ public static void TensorSpanFillTest()
             }
 
             a = [.. Enumerable.Range(0, 16)];
-            spanInt = a.AsTensorSpan(2,2,2,2);
+            spanInt = a.AsTensorSpan([2,2,2,2]);
             spanInt.Fill(-1);
             enumerator = spanInt.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1531,7 +1399,7 @@ public static void TensorSpanFillTest()
             }
 
             a = [.. Enumerable.Range(0, 24)];
-            spanInt = a.AsTensorSpan(3, 2, 2, 2);
+            spanInt = a.AsTensorSpan([3, 2, 2, 2]);
             spanInt.Fill(-1);
             enumerator = spanInt.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1544,7 +1412,7 @@ public static void TensorSpanFillTest()
         public static void TensorSpanClearTest()
         {
             int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-            TensorSpan<int> spanInt = a.AsTensorSpan(3, 3);
+            TensorSpan<int> spanInt = a.AsTensorSpan([3, 3]);
 
             var slice = spanInt.Slice(0..2, 0..2);
             slice.Clear();
@@ -1573,7 +1441,7 @@ public static void TensorSpanClearTest()
             }
 
             a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-            spanInt = a.AsTensorSpan(9);
+            spanInt = a.AsTensorSpan([9]);
             slice = spanInt.Slice(0..1);
             slice.Clear();
             Assert.Equal(0, slice[0]);
@@ -1598,7 +1466,7 @@ public static void TensorSpanClearTest()
             }
 
             a = [.. Enumerable.Range(0, 27)];
-            spanInt = a.AsTensorSpan(3, 3, 3);
+            spanInt = a.AsTensorSpan([3, 3, 3]);
             spanInt.Clear();
             enumerator = spanInt.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1607,7 +1475,7 @@ public static void TensorSpanClearTest()
             }
 
             a = [.. Enumerable.Range(0, 12)];
-            spanInt = a.AsTensorSpan(3, 2, 2);
+            spanInt = a.AsTensorSpan([3, 2, 2]);
             spanInt.Clear();
             enumerator = spanInt.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1616,7 +1484,7 @@ public static void TensorSpanClearTest()
             }
 
             a = [.. Enumerable.Range(0, 16)];
-            spanInt = a.AsTensorSpan(2, 2, 2, 2);
+            spanInt = a.AsTensorSpan([2, 2, 2, 2]);
             spanInt.Clear();
             enumerator = spanInt.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1625,7 +1493,7 @@ public static void TensorSpanClearTest()
             }
 
             a = [.. Enumerable.Range(0, 24)];
-            spanInt = a.AsTensorSpan(3, 2, 2, 2);
+            spanInt = a.AsTensorSpan([3, 2, 2, 2]);
             spanInt.Clear();
             enumerator = spanInt.GetEnumerator();
             while (enumerator.MoveNext())
@@ -1639,8 +1507,8 @@ public static void TensorSpanCopyTest()
         {
             int[] leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             int[] rightData = new int[9];
-            TensorSpan<int> leftSpan = leftData.AsTensorSpan(3, 3);
-            TensorSpan<int> rightSpan = rightData.AsTensorSpan(3, 3);
+            TensorSpan<int> leftSpan = leftData.AsTensorSpan([3, 3]);
+            TensorSpan<int> rightSpan = rightData.AsTensorSpan([3, 3]);
             leftSpan.CopyTo(rightSpan);
             var leftEnum = leftSpan.GetEnumerator();
             var rightEnum = rightSpan.GetEnumerator();
@@ -1658,16 +1526,16 @@ public static void TensorSpanCopyTest()
                 {
                     leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
                     rightData = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-                    TensorSpan<int> leftSpan = leftData.AsTensorSpan(9);
-                    TensorSpan<int> tensor = rightData.AsTensorSpan(rightData.Length);
+                    TensorSpan<int> leftSpan = leftData.AsTensorSpan([9]);
+                    TensorSpan<int> tensor = rightData.AsTensorSpan([rightData.Length]);
                     leftSpan.CopyTo(tensor);
                 }
             );
 
             leftData = [.. Enumerable.Range(0, 27)];
             rightData = [.. Enumerable.Range(0, 27)];
-            leftSpan = leftData.AsTensorSpan(3, 3, 3);
-            rightSpan = rightData.AsTensorSpan(3, 3, 3);
+            leftSpan = leftData.AsTensorSpan([3, 3, 3]);
+            rightSpan = rightData.AsTensorSpan([3, 3, 3]);
             leftSpan.CopyTo(rightSpan);
 
             while (leftEnum.MoveNext() && rightEnum.MoveNext())
@@ -1677,7 +1545,7 @@ public static void TensorSpanCopyTest()
 
             Assert.Throws<ArgumentException>(() =>
             {
-                var l = leftData.AsTensorSpan(3, 3, 3);
+                var l = leftData.AsTensorSpan([3, 3, 3]);
                 var r = new TensorSpan<int>();
                 l.CopyTo(r);
             });
@@ -1688,8 +1556,8 @@ public static void TensorSpanTryCopyTest()
         {
             int[] leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             int[] rightData = new int[9];
-            TensorSpan<int> leftSpan = leftData.AsTensorSpan(3, 3);
-            TensorSpan<int> rightSpan = rightData.AsTensorSpan(3, 3);
+            TensorSpan<int> leftSpan = leftData.AsTensorSpan([3, 3]);
+            TensorSpan<int> rightSpan = rightData.AsTensorSpan([3, 3]);
             var success = leftSpan.TryCopyTo(rightSpan);
             Assert.True(success);
             var leftEnum = leftSpan.GetEnumerator();
@@ -1705,16 +1573,16 @@ public static void TensorSpanTryCopyTest()
 
             leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             rightData = new int[15];
-            leftSpan = leftData.AsTensorSpan(9);
-            rightSpan = rightData.AsTensorSpan(15);
+            leftSpan = leftData.AsTensorSpan([9]);
+            rightSpan = rightData.AsTensorSpan([15]);
             success = leftSpan.TryCopyTo(rightSpan);
 
             Assert.False(success);
 
             leftData = [.. Enumerable.Range(0, 27)];
             rightData = [.. Enumerable.Range(0, 27)];
-            leftSpan = leftData.AsTensorSpan(3, 3, 3);
-            rightSpan = rightData.AsTensorSpan(3, 3, 3);
+            leftSpan = leftData.AsTensorSpan([3, 3, 3]);
+            rightSpan = rightData.AsTensorSpan([3, 3, 3]);
             success = leftSpan.TryCopyTo(rightSpan);
             Assert.True(success);
 
@@ -1723,7 +1591,7 @@ public static void TensorSpanTryCopyTest()
                 Assert.Equal(leftEnum.Current, rightEnum.Current);
             }
 
-            var l = leftData.AsTensorSpan(3, 3, 3);
+            var l = leftData.AsTensorSpan([3, 3, 3]);
             var r = new TensorSpan<int>();
             success = l.TryCopyTo(r);
             Assert.False(success);
@@ -1783,11 +1651,11 @@ public static void TensorSpanSliceTest()
 
             int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             int[] results = new int[9];
-            TensorSpan<int> spanInt = a.AsTensorSpan(3, 3);
+            TensorSpan<int> spanInt = a.AsTensorSpan([3, 3]);
 
-            Assert.Throws<IndexOutOfRangeException>(() => a.AsTensorSpan(2, 3).Slice(0..1));
-            Assert.Throws<IndexOutOfRangeException>(() => a.AsTensorSpan(2, 3).Slice(1..2));
-            Assert.Throws<ArgumentOutOfRangeException>(() => a.AsTensorSpan(2, 3).Slice(0..1, 5..6));
+            Assert.Throws<ArgumentOutOfRangeException>(() => a.AsTensorSpan([2, 3]).Slice(0..1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => a.AsTensorSpan([2, 3]).Slice(1..2));
+            Assert.Throws<ArgumentOutOfRangeException>(() => a.AsTensorSpan([2, 3]).Slice(0..1, 5..6));
 
             var sp = spanInt.Slice(1..3, 1..3);
             Assert.Equal(5, sp[0, 0]);
@@ -1827,7 +1695,7 @@ public static void TensorSpanSliceTest()
 
             sp = spanInt.Slice(0..1, 0..1);
             Assert.Equal(1, sp[0, 0]);
-            Assert.Throws<IndexOutOfRangeException>(() => a.AsTensorSpan(3, 3).Slice(0..1, 0..1)[0, 1]);
+            Assert.Throws<IndexOutOfRangeException>(() => a.AsTensorSpan([3, 3]).Slice(0..1, 0..1)[0, 1]);
             slice = [1];
             results = new int[1];
             sp.FlattenTo(results);
@@ -1856,7 +1724,7 @@ public static void TensorSpanSliceTest()
             }
 
             int[] numbers = [.. Enumerable.Range(0, 27)];
-            spanInt = numbers.AsTensorSpan(3, 3, 3);
+            spanInt = numbers.AsTensorSpan([3, 3, 3]);
             sp = spanInt.Slice(1..2, 1..2, 1..2);
             Assert.Equal(13, sp[0, 0, 0]);
             slice = [13];
@@ -1891,7 +1759,7 @@ public static void TensorSpanSliceTest()
             }
 
             numbers = [.. Enumerable.Range(0, 16)];
-            spanInt = numbers.AsTensorSpan(2, 2, 2, 2);
+            spanInt = numbers.AsTensorSpan([2, 2, 2, 2]);
             sp = spanInt.Slice(1..2, 0..2, 1..2, 0..2);
             Assert.Equal(10, sp[0,0,0,0]);
             Assert.Equal(11, sp[0,0,0,1]);
@@ -1913,7 +1781,7 @@ public static void TensorSpanSliceTest()
         public static void LongArrayAsTensorSpan()
         {
             long[] b = { 91, -92, 93, 94, -95 };
-            TensorSpan<long> spanLong = b.AsTensorSpan(5);
+            TensorSpan<long> spanLong = b.AsTensorSpan([5]);
             Assert.Equal(91, spanLong[0]);
             Assert.Equal(-92, spanLong[1]);
             Assert.Equal(93, spanLong[2]);
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
index fce9d8f68f474f..a2e0f203f2b6b6 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
@@ -6,7 +6,6 @@
 using System.Linq;
 using System.Runtime.InteropServices;
 using Xunit;
-using static System.Numerics.Tensors.Tests.TensorTests;
 
 namespace System.Numerics.Tensors.Tests
 {
@@ -14,7 +13,7 @@ public class TensorTests
     {
         #region TensorPrimitivesForwardsTests
         private void FillTensor<T>(Span<T> span)
-            where T : INumberBase<T>
+            where T : INumberBase<T>, IComparisonOperators<T, T, bool>
         {
             for (int i = 0; i < span.Length; i++)
             {
@@ -36,57 +35,57 @@ private static nint CalculateTotalLength(ReadOnlySpan<nint> lengths)
         }
 
         public delegate Tensor<T> PerformSpanInSpanOut<T>(in ReadOnlyTensorSpan<T> input);
-        public delegate void PerformCalculationSpanInSpanOut<T>(ReadOnlySpan<T> input, Span<T> output);
+        public delegate T PerformCalculationSpanInSpanOut<T>(T input);
 
         public static IEnumerable<object[]> SpanInSpanOutData()
         {
-            yield return Create<float>(TensorPrimitives.Abs<float>, Tensor.Abs);
-            yield return Create<float>(TensorPrimitives.Acos, Tensor.Acos);
-            yield return Create<float>(TensorPrimitives.Acosh, Tensor.Acosh);
-            yield return Create<float>(TensorPrimitives.AcosPi, Tensor.AcosPi);
-            yield return Create<float>(TensorPrimitives.Asin, Tensor.Asin);
-            yield return Create<float>(TensorPrimitives.Asinh, Tensor.Asinh);
-            yield return Create<float>(TensorPrimitives.AsinPi, Tensor.AsinPi);
-            yield return Create<float>(TensorPrimitives.Atan, Tensor.Atan);
-            yield return Create<float>(TensorPrimitives.Atanh, Tensor.Atanh);
-            yield return Create<float>(TensorPrimitives.AtanPi, Tensor.AtanPi);
-            yield return Create<float>(TensorPrimitives.Cbrt, Tensor.Cbrt);
-            yield return Create<float>(TensorPrimitives.Ceiling, Tensor.Ceiling);
-            yield return Create<float>(TensorPrimitives.Cos, Tensor.Cos);
-            yield return Create<float>(TensorPrimitives.Cosh, Tensor.Cosh);
-            yield return Create<float>(TensorPrimitives.CosPi, Tensor.CosPi);
-            yield return Create<float>(TensorPrimitives.DegreesToRadians, Tensor.DegreesToRadians);
-            yield return Create<float>(TensorPrimitives.Exp, Tensor.Exp);
-            yield return Create<float>(TensorPrimitives.Exp10, Tensor.Exp10);
-            yield return Create<float>(TensorPrimitives.Exp10M1, Tensor.Exp10M1);
-            yield return Create<float>(TensorPrimitives.Exp2, Tensor.Exp2);
-            yield return Create<float>(TensorPrimitives.Exp2M1, Tensor.Exp2M1);
-            yield return Create<float>(TensorPrimitives.ExpM1, Tensor.ExpM1);
-            yield return Create<float>(TensorPrimitives.Floor, Tensor.Floor);
-            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.Log10, Tensor.Log10);
-            yield return Create<float>(TensorPrimitives.Log10P1, Tensor.Log10P1);
-            yield return Create<float>(TensorPrimitives.Log2, Tensor.Log2);
-            yield return Create<float>(TensorPrimitives.Log2P1, Tensor.Log2P1);
-            yield return Create<float>(TensorPrimitives.LogP1, Tensor.LogP1);
-            yield return Create<float>(TensorPrimitives.Negate, Tensor.Negate);
-            yield return Create<float>(TensorPrimitives.OnesComplement, Tensor.OnesComplement);
-            yield return Create<int>(TensorPrimitives.PopCount, Tensor.PopCount);
-            yield return Create<float>(TensorPrimitives.RadiansToDegrees, Tensor.RadiansToDegrees);
-            yield return Create<float>(TensorPrimitives.Reciprocal, Tensor.Reciprocal);
-            yield return Create<float>(TensorPrimitives.Round, Tensor.Round);
-            yield return Create<float>(TensorPrimitives.Sigmoid, Tensor.Sigmoid);
-            yield return Create<float>(TensorPrimitives.Sin, Tensor.Sin);
-            yield return Create<float>(TensorPrimitives.Sinh, Tensor.Sinh);
-            yield return Create<float>(TensorPrimitives.SinPi, Tensor.SinPi);
-            yield return Create<float>(TensorPrimitives.SoftMax, Tensor.SoftMax);
-            yield return Create<float>(TensorPrimitives.Sqrt, Tensor.Sqrt);
-            yield return Create<float>(TensorPrimitives.Tan, Tensor.Tan);
-            yield return Create<float>(TensorPrimitives.Tanh, Tensor.Tanh);
-            yield return Create<float>(TensorPrimitives.TanPi, Tensor.TanPi);
-            yield return Create<float>(TensorPrimitives.Truncate, Tensor.Truncate);
+            yield return Create<float>(float.Abs, Tensor.Abs);
+            yield return Create<float>(float.Acos, Tensor.Acos);
+            yield return Create<float>(float.Acosh, Tensor.Acosh);
+            yield return Create<float>(float.AcosPi, Tensor.AcosPi);
+            yield return Create<float>(float.Asin, Tensor.Asin);
+            yield return Create<float>(float.Asinh, Tensor.Asinh);
+            yield return Create<float>(float.AsinPi, Tensor.AsinPi);
+            yield return Create<float>(float.Atan, Tensor.Atan);
+            yield return Create<float>(float.Atanh, Tensor.Atanh);
+            yield return Create<float>(float.AtanPi, Tensor.AtanPi);
+            yield return Create<float>(float.Cbrt, Tensor.Cbrt);
+            yield return Create<float>(float.Ceiling, Tensor.Ceiling);
+            yield return Create<float>(float.Cos, Tensor.Cos);
+            yield return Create<float>(float.Cosh, Tensor.Cosh);
+            yield return Create<float>(float.CosPi, Tensor.CosPi);
+            yield return Create<float>(float.DegreesToRadians, Tensor.DegreesToRadians);
+            yield return Create<float>(float.Exp, Tensor.Exp);
+            yield return Create<float>(float.Exp10, Tensor.Exp10);
+            yield return Create<float>(float.Exp10M1, Tensor.Exp10M1);
+            yield return Create<float>(float.Exp2, Tensor.Exp2);
+            yield return Create<float>(float.Exp2M1, Tensor.Exp2M1);
+            yield return Create<float>(float.ExpM1, Tensor.ExpM1);
+            yield return Create<float>(float.Floor, Tensor.Floor);
+            yield return Create<int>(int.LeadingZeroCount, Tensor.LeadingZeroCount);
+            yield return Create<int>(int.LeadingZeroCount, Tensor.LeadingZeroCount);
+            yield return Create<float>(float.Log, Tensor.Log);
+            yield return Create<float>(float.Log10, Tensor.Log10);
+            yield return Create<float>(float.Log10P1, Tensor.Log10P1);
+            yield return Create<float>(float.Log2, Tensor.Log2);
+            yield return Create<float>(float.Log2P1, Tensor.Log2P1);
+            yield return Create<float>(float.LogP1, Tensor.LogP1);
+            yield return Create<float>(f => -f, Tensor.Negate);
+            yield return Create<int>(f => ~f, Tensor.OnesComplement);
+            yield return Create<int>(int.PopCount, Tensor.PopCount);
+            yield return Create<float>(float.RadiansToDegrees, Tensor.RadiansToDegrees);
+            yield return Create<float>( f => 1 / f, Tensor.Reciprocal);
+            yield return Create<float>(float.Round, Tensor.Round);
+            //yield return Create<float>(float.Sigmoid, Tensor.Sigmoid);
+            yield return Create<float>(float.Sin, Tensor.Sin);
+            yield return Create<float>(float.Sinh, Tensor.Sinh);
+            yield return Create<float>(float.SinPi, Tensor.SinPi);
+            //yield return Create<float>(float.SoftMax, Tensor.SoftMax);
+            yield return Create<float>(float.Sqrt, Tensor.Sqrt);
+            yield return Create<float>(float.Tan, Tensor.Tan);
+            yield return Create<float>(float.Tanh, Tensor.Tanh);
+            yield return Create<float>(float.TanPi, Tensor.TanPi);
+            yield return Create<float>(float.Truncate, Tensor.Truncate);
 
             static object[] Create<T>(PerformCalculationSpanInSpanOut<T> tensorPrimitivesMethod, PerformSpanInSpanOut<T> tensorOperation)
                 => new object[] { tensorPrimitivesMethod, tensorOperation };
@@ -94,7 +93,7 @@ static object[] Create<T>(PerformCalculationSpanInSpanOut<T> tensorPrimitivesMet
 
         [Theory, MemberData(nameof(SpanInSpanOutData))]
         public void TensorExtensionsSpanInSpanOut<T>(PerformCalculationSpanInSpanOut<T> tensorPrimitivesOperation, PerformSpanInSpanOut<T> tensorOperation)
-            where T: INumberBase<T>
+            where T: INumberBase<T>, IComparisonOperators<T, T, bool>
         {
             Assert.All(Helpers.TensorShapes, tensorLength =>
             {
@@ -104,16 +103,15 @@ public void TensorExtensionsSpanInSpanOut<T>(PerformCalculationSpanInSpanOut<T>
 
                 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);
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref results.GetPinnableReference(), (int)length);
 
                 for (int i = 0; i < data.Length; i++)
                 {
-                    Assert.Equal(expectedOutput[i], span[i]);
+                    Assert.Equal(tensorPrimitivesOperation(data[i]), span[i]);
                 }
             });
         }
@@ -128,9 +126,33 @@ public static IEnumerable<object[]> SpanInFloatOutData()
             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);
+            yield return Create<float>(x =>
+            {
+                float sum = 0;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    sum += x[i] * x[i];
+                }
+                return float.Sqrt(sum);
+            }, Tensor.Norm);
+            yield return Create<float>(x =>
+            {
+                float sum = 1;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    sum *= x[i];
+                }
+                return sum;
+            }, Tensor.Product);
+            yield return Create<float>(x =>
+            {
+                float sum = 0;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    sum+= x[i];
+                }
+                return sum;
+            }, Tensor.Sum);
 
             static object[] Create<T>(PerformCalculationSpanInTOut<T> tensorPrimitivesMethod, PerformSpanInTOut<T> tensorOperation)
                 => new object[] { tensorPrimitivesMethod, tensorOperation };
@@ -138,7 +160,7 @@ static object[] Create<T>(PerformCalculationSpanInTOut<T> tensorPrimitivesMethod
 
         [Theory, MemberData(nameof(SpanInFloatOutData))]
         public void TensorExtensionsSpanInTOut<T>(PerformCalculationSpanInTOut<T> tensorPrimitivesOperation, PerformSpanInTOut<T> tensorOperation)
-            where T : INumberBase<T>
+            where T : INumberBase<T>, IComparisonOperators<T, T, bool>
         {
             Assert.All(Helpers.TensorShapes, tensorLength =>
             {
@@ -175,7 +197,7 @@ static object[] Create<T>(PerformCalculationTwoSpanInSpanOut<T> tensorPrimitives
 
         [Theory, MemberData(nameof(TwoSpanInSpanOutData))]
         public void TensorExtensionsTwoSpanInSpanOut<T>(PerformCalculationTwoSpanInSpanOut<T> tensorPrimitivesOperation, PerformTwoSpanInSpanOut<T> tensorOperation)
-            where T: INumberBase<T>
+            where T: INumberBase<T>, IComparisonOperators<T, T, bool>
         {
             Assert.All(Helpers.TensorShapes, tensorLength =>
             {
@@ -206,8 +228,24 @@ public void TensorExtensionsTwoSpanInSpanOut<T>(PerformCalculationTwoSpanInSpanO
         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);
+            yield return Create<float>((x, y) =>
+            {
+                float sum = 0;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    sum += (x[i] - y[i]) * (x[i] - y[i]);
+                }
+                return float.Sqrt(sum);
+            }, Tensor.Distance);
+            yield return Create<float>((x, y) =>
+            {
+                float sum = 0;
+                for (int i = 0; i < x.Length; i++)
+                {
+                    sum += x[i] * y[i];
+                }
+                return sum;
+            }, Tensor.Dot);
 
             static object[] Create<T>(PerformCalculationTwoSpanInFloatOut<T> tensorPrimitivesMethod, PerformTwoSpanInFloatOut<T> tensorOperation)
                 => new object[] { tensorPrimitivesMethod, tensorOperation };
@@ -215,7 +253,7 @@ static object[] Create<T>(PerformCalculationTwoSpanInFloatOut<T> tensorPrimitive
 
         [Theory, MemberData(nameof(TwoSpanInFloatOutData))]
         public void TensorExtensionsTwoSpanInFloatOut<T>(PerformCalculationTwoSpanInFloatOut<T> tensorPrimitivesOperation, PerformTwoSpanInFloatOut<T> tensorOperation)
-            where T: INumberBase<T>
+            where T: INumberBase<T>, IComparisonOperators<T, T, bool>
         {
             Assert.All(Helpers.TensorShapes, tensorLength =>
             {
@@ -241,7 +279,7 @@ public static void TensorLargeDimensionsTests()
         {
             int[] a = { 91, 92, -93, 94, 95, -96 };
             int[] results = new int[6];
-            Tensor<int> tensor = Tensor.Create<int>(a,[1, 1, 1, 1, 1, 6]);
+            Tensor<int> tensor = Tensor.Create<int>(a, lengths: [1, 1, 1, 1, 1, 6]);
             Assert.Equal(6, tensor.Rank);
 
             Assert.Equal(6, tensor.Lengths.Length);
@@ -252,11 +290,11 @@ public static void TensorLargeDimensionsTests()
             Assert.Equal(1, tensor.Lengths[4]);
             Assert.Equal(6, tensor.Lengths[5]);
             Assert.Equal(6, tensor.Strides.Length);
-            Assert.Equal(6, tensor.Strides[0]);
-            Assert.Equal(6, tensor.Strides[1]);
-            Assert.Equal(6, tensor.Strides[2]);
-            Assert.Equal(6, tensor.Strides[3]);
-            Assert.Equal(6, tensor.Strides[4]);
+            Assert.Equal(0, tensor.Strides[0]);
+            Assert.Equal(0, tensor.Strides[1]);
+            Assert.Equal(0, tensor.Strides[2]);
+            Assert.Equal(0, tensor.Strides[3]);
+            Assert.Equal(0, tensor.Strides[4]);
             Assert.Equal(1, tensor.Strides[5]);
             Assert.Equal(91, tensor[0, 0, 0, 0, 0, 0]);
             Assert.Equal(92, tensor[0, 0, 0, 0, 0, 1]);
@@ -269,7 +307,7 @@ public static void TensorLargeDimensionsTests()
 
             a = [91, 92, -93, 94, 95, -96, -91, -92, 93, -94, -95, 96];
             results = new int[12];
-            tensor = Tensor.Create<int>(a, [1, 2, 2, 1, 1, 3]);
+            tensor = Tensor.Create<int>(a, lengths: [1, 2, 2, 1, 1, 3]);
             Assert.Equal(6, tensor.Lengths.Length);
             Assert.Equal(1, tensor.Lengths[0]);
             Assert.Equal(2, tensor.Lengths[1]);
@@ -278,11 +316,11 @@ public static void TensorLargeDimensionsTests()
             Assert.Equal(1, tensor.Lengths[4]);
             Assert.Equal(3, tensor.Lengths[5]);
             Assert.Equal(6, tensor.Strides.Length);
-            Assert.Equal(12, tensor.Strides[0]);
+            Assert.Equal(0, tensor.Strides[0]);
             Assert.Equal(6, tensor.Strides[1]);
             Assert.Equal(3, tensor.Strides[2]);
-            Assert.Equal(3, tensor.Strides[3]);
-            Assert.Equal(3, tensor.Strides[4]);
+            Assert.Equal(0, tensor.Strides[3]);
+            Assert.Equal(0, tensor.Strides[4]);
             Assert.Equal(1, tensor.Strides[5]);
             Assert.Equal(91, tensor[0, 0, 0, 0, 0, 0]);
             Assert.Equal(92, tensor[0, 0, 0, 0, 0, 1]);
@@ -309,11 +347,11 @@ public static void TensorFactoryCreateUninitializedTests()
             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.Equal(0, t1.Strides[0]);
             Assert.False(t1.IsPinned);
 
             // Make sure can't index too many dimensions
-            Assert.Throws<IndexOutOfRangeException>(() =>
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
             {
                 var x = t1[1, 1];
             });
@@ -367,7 +405,7 @@ public static void TensorFactoryCreateUninitializedTests()
             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.Equal(0, t1.Strides[0]);
             Assert.True(t1.IsPinned);
 
             // Make sure 2D array works with basic strides
@@ -428,7 +466,7 @@ public static void TensorFactoryCreateUninitializedTests()
             Assert.Equal(t1[1, 0], t1[1, 1]);
 
             // Make sure you can't overlap elements using strides
-            Assert.Throws<ArgumentOutOfRangeException>(() => {
+            Assert.Throws<ArgumentException>(() => {
                 var t1 = Tensor.CreateUninitialized<int>([2, 2], [1, 1], false);
             });
         }
@@ -442,12 +480,12 @@ public static void TensorFactoryCreateTests()
             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.Equal(0, t1.Strides[0]);
             Assert.False(t1.IsPinned);
             Assert.Equal(0, t1[0]);
 
             // Make sure can't index too many dimensions
-            Assert.Throws<IndexOutOfRangeException>(() =>
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
             {
                 var x = t1[1, 1];
             });
@@ -488,20 +526,18 @@ public static void TensorFactoryCreateTests()
 
             // 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.Equal(0, t1.Rank);
+            Assert.Equal(0, t1.Lengths.Length);
+            Assert.Equal(0, t1.Strides.Length);
             Assert.False(t1.IsPinned);
 
             // Make sure pinned works
-            t1 = Tensor.Create<int>([1], true);
+            t1 = Tensor.Create<int>([(nint)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.Equal(0, t1.Strides[0]);
             Assert.True(t1.IsPinned);
             Assert.Equal(0, t1[0]);
 
@@ -558,12 +594,10 @@ public static void TensorFactoryCreateTests()
 
             // 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);
+                var t1 = Tensor.Create<int>([-1, (nint)2], false);
             });
             Assert.Throws<ArgumentOutOfRangeException>(() => {
-                Span<int> a = [91, 92, -93, 94];
-                var t1 = Tensor.Create<int>([1, -2], false);
+                var t1 = Tensor.Create<int>([(nint)1, -2], false);
             });
 
             // Make sure 2D array works with strides to hit element 0,0,2,2
@@ -577,7 +611,7 @@ public static void TensorFactoryCreateTests()
             Assert.Equal(-93, t1[1, 1]);
 
             // Make sure you can't overlap elements using strides
-            Assert.Throws<ArgumentOutOfRangeException>(() => {
+            Assert.Throws<ArgumentException>(() => {
                 var t1 = Tensor.Create<int>((Span<nint>)[2, 2], [1, 1], false);
             });
         }
@@ -588,20 +622,20 @@ 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> left = Tensor.Create<float>(a, lengths: [2,3]);
+            Tensor<float> right = Tensor.Create<float>(b, lengths: [2,3]);
+
+            Tensor<float> result = Tensor.Create<float>(a, lengths: [2, 1]);
+
+            result[0, 0] = Tensor.CosineSimilarity(left.AsReadOnlyTensorSpan([0..1, 0.. ]), right[0..1, 0..]);
+            result[1, 0] = Tensor.CosineSimilarity(left.AsReadOnlyTensorSpan([1.., 0..]), right[1.., 0..]);
 
-            Tensor<float> result = Tensor.CosineSimilarity(left.AsReadOnlyTensorSpan(), right);
             Assert.Equal(2, result.Rank);
             Assert.Equal(2, result.Lengths[0]);
-            Assert.Equal(2, result.Lengths[1]);
-
+            Assert.Equal(1, 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);
+            Assert.Equal(0.81649, result[1, 0], .00001);
         }
 
         //[Fact]
@@ -681,37 +715,38 @@ public static void TensorCosineSimilarityTests()
         [Fact]
         public static void TensorMultiplyTests()
         {
-            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 3), default);
-            Tensor<int> t1 = Tensor.Create(Enumerable.Range(0, 3), [3, 1]);
+            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 3));
+            Tensor<int> t1 = Tensor.Create(Enumerable.Range(0, 3), lengths: [3, 1]);
+
+            // TODO: This double broadcast will be added back in the future
+            //Tensor<int> t2 = Tensor.Multiply(t0.AsReadOnlyTensorSpan(), t1);
+            //Assert.Equal([3,3], t2.Lengths);
+            //Assert.Equal(0, t2[0, 0]);
+            //Assert.Equal(0, t2[0, 1]);
+            //Assert.Equal(0, t2[0, 2]);
+            //Assert.Equal(0, t2[1, 0]);
+            //Assert.Equal(1, t2[1, 1]);
+            //Assert.Equal(2, t2[1, 2]);
+            //Assert.Equal(0, t2[2, 0]);
+            //Assert.Equal(2, t2[2, 1]);
+            //Assert.Equal(4, t2[2, 2]);
+
+            //t2 = Tensor.Multiply(t1.AsReadOnlyTensorSpan(), t0);
+
+            //Assert.Equal([3, 3], t2.Lengths);
+            //Assert.Equal(0, t2[0, 0]);
+            //Assert.Equal(0, t2[0, 1]);
+            //Assert.Equal(0, t2[0, 2]);
+            //Assert.Equal(0, t2[1, 0]);
+            //Assert.Equal(1, t2[1, 1]);
+            //Assert.Equal(2, t2[1, 2]);
+            //Assert.Equal(0, t2[2, 0]);
+            //Assert.Equal(2, t2[2, 1]);
+            //Assert.Equal(4, t2[2, 2]);
+
+            t1 = Tensor.Create(Enumerable.Range(0, 9), lengths: [3, 3]);
             Tensor<int> t2 = Tensor.Multiply(t0.AsReadOnlyTensorSpan(), t1);
 
-            Assert.Equal([3,3], t2.Lengths);
-            Assert.Equal(0, t2[0, 0]);
-            Assert.Equal(0, t2[0, 1]);
-            Assert.Equal(0, t2[0, 2]);
-            Assert.Equal(0, t2[1, 0]);
-            Assert.Equal(1, t2[1, 1]);
-            Assert.Equal(2, t2[1, 2]);
-            Assert.Equal(0, t2[2, 0]);
-            Assert.Equal(2, t2[2, 1]);
-            Assert.Equal(4, t2[2, 2]);
-
-            t2 = Tensor.Multiply(t1.AsReadOnlyTensorSpan(), t0);
-
-            Assert.Equal([3, 3], t2.Lengths);
-            Assert.Equal(0, t2[0, 0]);
-            Assert.Equal(0, t2[0, 1]);
-            Assert.Equal(0, t2[0, 2]);
-            Assert.Equal(0, t2[1, 0]);
-            Assert.Equal(1, t2[1, 1]);
-            Assert.Equal(2, t2[1, 2]);
-            Assert.Equal(0, t2[2, 0]);
-            Assert.Equal(2, t2[2, 1]);
-            Assert.Equal(4, t2[2, 2]);
-
-            t1 = Tensor.Create(Enumerable.Range(0, 9), [3, 3]);
-            t2 = Tensor.Multiply(t0.AsReadOnlyTensorSpan(), t1);
-
             Assert.Equal([3, 3], t2.Lengths);
             Assert.Equal(0, t2[0, 0]);
             Assert.Equal(1, t2[0, 1]);
@@ -727,7 +762,7 @@ public static void TensorMultiplyTests()
         [Fact]
         public static void TensorBroadcastTests()
         {
-            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 3), [1, 3, 1, 1, 1]);
+            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 3), lengths: [1, 3, 1, 1, 1]);
             Tensor<int> t1 = Tensor.Broadcast<int>(t0, [1, 3, 1, 2, 1]);
 
             Assert.Equal([1, 3, 1, 2, 1], t1.Lengths);
@@ -749,8 +784,8 @@ public static void TensorBroadcastTests()
             Assert.Equal(2, t1[0, 2, 0, 0, 0]);
             Assert.Equal(2, t1[0, 2, 1, 0, 0]);
 
-            t0 = Tensor.Create(Enumerable.Range(0, 3), [1, 3]);
-            t1 = Tensor.Create(Enumerable.Range(0, 3), [3, 1]);
+            t0 = Tensor.Create(Enumerable.Range(0, 3), lengths: [1, 3]);
+            t1 = Tensor.Create(Enumerable.Range(0, 3), lengths: [3, 1]);
             var t2 = Tensor.Broadcast<int>(t0, [3, 3]);
             Assert.Equal([3, 3], t2.Lengths);
 
@@ -764,7 +799,7 @@ public static void TensorBroadcastTests()
             Assert.Equal(1, t2[2, 1]);
             Assert.Equal(2, t2[2, 2]);
 
-            t1 = Tensor.Create(Enumerable.Range(0, 3), [3, 1]);
+            t1 = Tensor.Create(Enumerable.Range(0, 3), lengths: [3, 1]);
             t2 = Tensor.Broadcast<int>(t1, [3, 3]);
             Assert.Equal([3, 3], t2.Lengths);
 
@@ -810,7 +845,7 @@ public static void TensorBroadcastTests()
         [Fact]
         public static void TensorResizeTests()
         {
-            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 8), [2, 2, 2]);
+            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 8), lengths: [2, 2, 2]);
             var t1 = Tensor.Resize(t0, [1]);
             Assert.Equal([1], t1.Lengths);
             Assert.Equal(0, t1[0]);
@@ -858,7 +893,7 @@ public static void TensorResizeTests()
         [Fact]
         public static void TensorSplitTests()
         {
-            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 8), [2, 2, 2]);
+            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 8), lengths: [2, 2, 2]);
             var t1 = Tensor.Split<int>(t0, 2, 0);
             Assert.Equal([1, 2, 2], t1[0].Lengths);
             Assert.Equal([1, 2, 2], t1[1].Lengths);
@@ -899,7 +934,7 @@ public static void TensorSplitTests()
         [Fact]
         public static void TensorReverseTests()
         {
-            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 8), [2, 2, 2]);
+            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 8), lengths: [2, 2, 2]);
             var t1 = Tensor.Reverse<int>(t0);
             Assert.Equal(7, t1[0, 0, 0]);
             Assert.Equal(6, t1[0, 0, 1]);
@@ -944,9 +979,9 @@ public static void TensorReverseTests()
         [Fact]
         public static void TensorSetSliceTests()
         {
-            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 10), [2, 5]);
-            Tensor<int> t1 = Tensor.Create(Enumerable.Range(10, 10), [2, 5]);
-            Tensor.SetSlice(t0, t1);
+            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 10), lengths: [2, 5]);
+            Tensor<int> t1 = Tensor.Create(Enumerable.Range(10, 10), lengths: [2, 5]);
+            Tensor.SetSlice(t0, t1, .., ..);
 
             Assert.Equal(10, t0[0, 0]);
             Assert.Equal(11, t0[0, 1]);
@@ -959,8 +994,8 @@ public static void TensorSetSliceTests()
             Assert.Equal(18, t0[1, 3]);
             Assert.Equal(19, t0[1, 4]);
 
-            t0 = Tensor.Create(Enumerable.Range(0, 10), [2, 5]);
-            t1 = Tensor.Create(Enumerable.Range(10, 5), [1, 5]);
+            t0 = Tensor.Create(Enumerable.Range(0, 10), lengths: [2, 5]);
+            t1 = Tensor.Create(Enumerable.Range(10, 5), lengths: [1, 5]);
             t0.SetSlice(t1, 0..1, ..);
 
             Assert.Equal(10, t0[0, 0]);
@@ -974,8 +1009,8 @@ public static void TensorSetSliceTests()
             Assert.Equal(8, t0[1, 3]);
             Assert.Equal(9, t0[1, 4]);
 
-            t0 = Tensor.Create(Enumerable.Range(0, 10), [2, 5]);
-            t1 = Tensor.Create(Enumerable.Range(10, 5), [1, 5]);
+            t0 = Tensor.Create(Enumerable.Range(0, 10), lengths: [2, 5]);
+            t1 = Tensor.Create(Enumerable.Range(10, 5), lengths: [1, 5]);
             Tensor.SetSlice(t0, t1, 1..2, ..);
 
             Assert.Equal(0, t0[0, 0]);
@@ -993,8 +1028,8 @@ public static void TensorSetSliceTests()
         [Fact]
         public static void TensorStackTests()
         {
-            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 10), [2, 5]);
-            Tensor<int> t1 = Tensor.Create(Enumerable.Range(0, 10), [2, 5]);
+            Tensor<int> t0 = Tensor.Create(Enumerable.Range(0, 10), lengths: [2, 5]);
+            Tensor<int> t1 = Tensor.Create(Enumerable.Range(0, 10), lengths: [2, 5]);
 
             var resultTensor = Tensor.Stack([t0, t1]);
             Assert.Equal(3, resultTensor.Rank);
@@ -1078,8 +1113,8 @@ public static void TensorStackTests()
             Assert.Equal(9, resultTensor[1, 4, 1]);
 
             // stacking 2x2 tensors along dimension 1
-            Tensor<int> v1 = Tensor.Create([1, 2, 3, 4], [2, 2]);
-            Tensor<int> v2 = Tensor.Create([10, 20, 30, 40], [2, 2]);
+            Tensor<int> v1 = Tensor.Create([1, 2, 3, 4], lengths: [2, 2]);
+            Tensor<int> v2 = Tensor.Create([10, 20, 30, 40], lengths: [2, 2]);
             
             resultTensor = Tensor.StackAlongDimension(1, [v1, v2]);
             
@@ -1098,9 +1133,7 @@ public static void TensorStackTests()
             Assert.Equal(30, resultTensor[1, 1, 0]);
             Assert.Equal(40, resultTensor[1, 1, 1]);
 
-            resultTensor = Tensor.StackAlongDimension(0, [v1, v2]);
-
-            Tensor<int> resultTensor2 = Tensor.Create<int>([2, 2, 2]);
+            Tensor<int> resultTensor2 = Tensor.Create<int>([(nint)2, 2, 2]);
             Tensor.StackAlongDimension([v1, v2], resultTensor2, 1);
 
             Assert.Equal(3, resultTensor2.Rank);
@@ -1122,7 +1155,7 @@ public static void TensorStackTests()
         [Fact]
         public static void TensorStdDevTests()
         {
-            Tensor<float> t0 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), [2, 2]);
+            Tensor<float> t0 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), lengths: [2, 2]);
 
             Assert.Equal(StdDev([0, 1, 2, 3]), Tensor.StdDev<float>(t0), .1);
 
@@ -1140,7 +1173,7 @@ public static void TensorStdDevTests()
         public static void TensorSumTests()
         {
             float[] values = new float[] { 1, 2, 3, 4, 5, 6 };
-            Tensor<float> t0 = Tensor.Create<float>(new float[] { 1, 2, 3, 4, 5, 6 }, [2, 3]);
+            Tensor<float> t0 = Tensor.Create<float>(new float[] { 1, 2, 3, 4, 5, 6 }, lengths: [2, 3]);
             float sum = Tensor.Sum<float>(t0);
             Assert.Equal(21, sum);
 
@@ -1169,11 +1202,11 @@ public static void TensorSumTests()
             sum = Tensor.Sum<float>(t1);
             Assert.Equal(9, sum);
 
-            Assert.Throws<IndexOutOfRangeException>(()=> new Tensor<float>(new float[] { 1, 2, 3, 4, 5, 6 }, [2, 3], -1));
-            Assert.Throws<IndexOutOfRangeException>(()=> new Tensor<float>(new float[] { 1, 2, 3, 4, 5, 6 }, [2, 3], 100));
-            Assert.Throws<IndexOutOfRangeException>(()=> new Tensor<float>(new float[] { 1, 2, 3, 4, 5, 6 }, [2, 3], int.MinValue));
-            Assert.Throws<IndexOutOfRangeException>(()=> new Tensor<float>(new float[] { 1, 2, 3, 4, 5, 6 }, [2, 3], int.MaxValue));
-            Assert.Throws<ArgumentException>(()=> new Tensor<float>(new float[] { 1, 2, 3, 4, 5, 6 }, [2, 3], 2));
+            Assert.Throws<ArgumentOutOfRangeException>(()=> Tensor.Create<float>(new float[] { 1, 2, 3, 4, 5, 6 }, start: -1, lengths: [2, 3], strides: []));
+            Assert.Throws<ArgumentOutOfRangeException>(()=> Tensor.Create<float>(new float[] { 1, 2, 3, 4, 5, 6 }, start: 100, lengths: [2, 3], strides: []));
+            Assert.Throws<ArgumentOutOfRangeException>(()=> Tensor.Create<float>(new float[] { 1, 2, 3, 4, 5, 6 }, start: int.MinValue, lengths: [2, 3], strides: []));
+            Assert.Throws<ArgumentOutOfRangeException>(()=> Tensor.Create<float>(new float[] { 1, 2, 3, 4, 5, 6 }, start: int.MaxValue, lengths: [2, 3], strides: []));
+            Assert.Throws<ArgumentOutOfRangeException>(()=> Tensor.Create<float>(new float[] { 1, 2, 3, 4, 5, 6 }, start: 2, lengths: [2, 3], strides: []));
         }
 
         public static float StdDev(float[] values)
@@ -1190,7 +1223,7 @@ public static float StdDev(float[] values)
         [Fact]
         public static void TensorMeanTests()
         {
-            Tensor<float> t0 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), [2, 2]);
+            Tensor<float> t0 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), lengths: [2, 2]);
 
             Assert.Equal(Mean([0, 1, 2, 3]), Tensor.Average<float>(t0), .1);
         }
@@ -1208,8 +1241,8 @@ public static float Mean(float[] values)
         [Fact]
         public static void TensorConcatenateTests()
         {
-            Tensor<float> t0 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), [2, 2]);
-            Tensor<float> t1 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), [2, 2]);
+            Tensor<float> t0 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), lengths: [2, 2]);
+            Tensor<float> t1 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), lengths: [2, 2]);
             var resultTensor = Tensor.Concatenate([t0, t1]);
 
             Assert.Equal(2, resultTensor.Rank);
@@ -1249,7 +1282,7 @@ public static void TensorConcatenateTests()
             Assert.Equal(2, resultTensor[6]);
             Assert.Equal(3, resultTensor[7]);
 
-            Tensor<float> t2 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), [2, 2]);
+            Tensor<float> t2 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), lengths: [2, 2]);
             resultTensor = Tensor.Concatenate([t0, t1, t2]);
 
             Assert.Equal(2, resultTensor.Rank);
@@ -1303,9 +1336,9 @@ public static void TensorConcatenateTests()
             Assert.Equal(2, resultTensor[1, 4]);
             Assert.Equal(3, resultTensor[1, 5]);
 
-            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), [2, 3, 2]);
-            t1 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), [2, 3, 2]);
-            t2 = Tensor.Create<float>((Enumerable.Range(0, 8).Select(i => (float)i)), [2, 2, 2]);
+            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), lengths: [2, 3, 2]);
+            t1 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), lengths: [2, 3, 2]);
+            t2 = Tensor.Create<float>((Enumerable.Range(0, 8).Select(i => (float)i)), lengths: [2, 2, 2]);
             Assert.Throws<ArgumentException>(() => Tensor.ConcatenateOnDimension(0, [t0, t1, t2]));
             Assert.Throws<ArgumentException>(() => Tensor.ConcatenateOnDimension(2, [t0, t1, t2]));
             Assert.Throws<ArgumentException>(() => Tensor.ConcatenateOnDimension(5, [t0, t1, t2]));
@@ -1330,9 +1363,9 @@ public static void TensorConcatenateTests()
                 Helpers.AdjustIndices(resultTensor.Rank - 1, 1, ref indices, resultTensor.Lengths);
             }
 
-            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), [2, 2, 3]);
-            t1 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), [2, 2, 3]);
-            t2 = Tensor.Create<float>((Enumerable.Range(0, 8).Select(i => (float)i)), [2, 2, 2]);
+            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), lengths: [2, 2, 3]);
+            t1 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), lengths: [2, 2, 3]);
+            t2 = Tensor.Create<float>((Enumerable.Range(0, 8).Select(i => (float)i)), lengths: [2, 2, 2]);
             Assert.Throws<ArgumentException>(() => Tensor.Concatenate([t0, t1, t2]));
             Assert.Throws<ArgumentException>(() => Tensor.ConcatenateOnDimension(1, [t0, t1, t2]));
             resultTensor = Tensor.ConcatenateOnDimension(2, [t0, t1, t2]);
@@ -1349,9 +1382,9 @@ public static void TensorConcatenateTests()
                 Helpers.AdjustIndices(resultTensor.Rank - 1, 1, ref indices, resultTensor.Lengths);
             }
 
-            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), [3, 2, 2]);
-            t1 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), [3, 2, 2]);
-            t2 = Tensor.Create<float>((Enumerable.Range(0, 8).Select(i => (float)i)), [2, 2, 2]);
+            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), lengths: [3, 2, 2]);
+            t1 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), lengths: [3, 2, 2]);
+            t2 = Tensor.Create<float>((Enumerable.Range(0, 8).Select(i => (float)i)), lengths: [2, 2, 2]);
             Assert.Throws<ArgumentException>(() => Tensor.ConcatenateOnDimension(1, [t0, t1, t2]));
             Assert.Throws<ArgumentException>(() => Tensor.ConcatenateOnDimension(2, [t0, t1, t2]));
             resultTensor = Tensor.ConcatenateOnDimension(0, [t0, t1, t2]);
@@ -1372,16 +1405,16 @@ public static void TensorConcatenateTests()
         [Fact]
         public static void TensorTransposeTests()
         {
-            Tensor<float> t0 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), [2, 2]);
-            var t1 = Tensor.PermuteDimensions(t0);
+            Tensor<float> t0 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), lengths: [2, 2]);
+            var t1 = t0.PermuteDimensions([]);
 
             Assert.Equal(0, t1[0, 0]);
             Assert.Equal(2, t1[0, 1]);
             Assert.Equal(1, t1[1, 0]);
             Assert.Equal(3, t1[1, 1]);
 
-            t0 = Tensor.Create<float>((Enumerable.Range(0, 6).Select(i => (float)i)), [2, 3]);
-            t1 = Tensor.PermuteDimensions(t0);
+            t0 = Tensor.Create<float>((Enumerable.Range(0, 6).Select(i => (float)i)), lengths: [2, 3]);
+            t1 = t0.PermuteDimensions([]);
 
             Assert.Equal(3, t1.Lengths[0]);
             Assert.Equal(2, t1.Lengths[1]);
@@ -1392,8 +1425,8 @@ public static void TensorTransposeTests()
             Assert.Equal(2, t1[2, 0]);
             Assert.Equal(5, t1[2, 1]);
 
-            t0 = Tensor.Create<float>((Enumerable.Range(0, 6).Select(i => (float)i)), [1, 2, 3]);
-            t1 = Tensor.PermuteDimensions(t0);
+            t0 = Tensor.Create<float>((Enumerable.Range(0, 6).Select(i => (float)i)), lengths: [1, 2, 3]);
+            t1 = t0.PermuteDimensions([]);
 
             Assert.Equal(3, t1.Lengths[0]);
             Assert.Equal(2, t1.Lengths[1]);
@@ -1405,8 +1438,8 @@ public static void TensorTransposeTests()
             Assert.Equal(2, t1[2, 0, 0]);
             Assert.Equal(5, t1[2, 1, 0]);
 
-            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), [2, 2, 3]);
-            t1 = Tensor.PermuteDimensions(t0);
+            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), lengths: [2, 2, 3]);
+            t1 = t0.PermuteDimensions([]);
 
             Assert.Equal(3, t1.Lengths[0]);
             Assert.Equal(2, t1.Lengths[1]);
@@ -1424,8 +1457,8 @@ public static void TensorTransposeTests()
             Assert.Equal(5, t1[2, 1, 0]);
             Assert.Equal(11, t1[2, 1, 1]);
 
-            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), [2, 2, 3]);
-            t1 = Tensor.PermuteDimensions(t0, 1, 2, 0);
+            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), lengths: [2, 2, 3]);
+            t1 = t0.PermuteDimensions([1, 2, 0]);
 
             Assert.Equal(2, t1.Lengths[0]);
             Assert.Equal(3, t1.Lengths[1]);
@@ -1447,7 +1480,7 @@ public static void TensorTransposeTests()
         [Fact]
         public static void TensorPermuteTests()
         {
-            Tensor<float> t0 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), [2, 2]);
+            Tensor<float> t0 = Tensor.Create<float>((Enumerable.Range(0, 4).Select(i => (float)i)), lengths: [2, 2]);
             var t1 = Tensor.Transpose(t0);
 
             Assert.Equal(0, t1[0, 0]);
@@ -1455,7 +1488,7 @@ public static void TensorPermuteTests()
             Assert.Equal(1, t1[1, 0]);
             Assert.Equal(3, t1[1, 1]);
 
-            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), [2, 2, 3]);
+            t0 = Tensor.Create<float>((Enumerable.Range(0, 12).Select(i => (float)i)), lengths: [2, 2, 3]);
             t1 = Tensor.Transpose(t0);
 
             Assert.Equal(2, t1.Lengths[0]);
@@ -1479,7 +1512,7 @@ public static void TensorPermuteTests()
         public static void IntArrayAsTensor()
         {
             int[] a = [91, 92, -93, 94];
-            TensorSpan<int> t1 = a.AsTensorSpan(4);
+            TensorSpan<int> t1 = a.AsTensorSpan();
             nint[] dims = [4];
             var tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             t1.CopyTo(tensor);
@@ -1508,7 +1541,7 @@ public static void IntArrayAsTensor()
             a[1] = 92;
             a[2] = -93;
             a[3] = 94;
-            t1 = a.AsTensorSpan(2, 2);
+            t1 = a.AsTensorSpan([2, 2]);
             dims = [2, 2];
             tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             t1.CopyTo(tensor);
@@ -1613,7 +1646,7 @@ public static void TensorFillTest()
         public static void TensorClearTest()
         {
             int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-            TensorSpan<int> t1 = a.AsTensorSpan(3, 3);
+            TensorSpan<int> t1 = a.AsTensorSpan([3, 3]);
             var tensor = Tensor.CreateUninitialized<int>([3, 3], false);
             t1.CopyTo(tensor);
             var slice = tensor.Slice(0..2, 0..2);
@@ -1643,7 +1676,7 @@ public static void TensorClearTest()
             }
 
             a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-            t1 = a.AsTensorSpan(9);
+            t1 = a.AsTensorSpan([9]);
             tensor = Tensor.CreateUninitialized<int>([9], false);
             t1.CopyTo(tensor);
             slice = tensor.Slice(0..1);
@@ -1670,7 +1703,7 @@ public static void TensorClearTest()
             }
 
             a = [.. Enumerable.Range(0, 27)];
-            t1 = a.AsTensorSpan(3, 3, 3);
+            t1 = a.AsTensorSpan([3, 3, 3]);
             tensor = Tensor.CreateUninitialized<int>([3, 3, 3], false);
             t1.CopyTo(tensor);
             tensor.Clear();
@@ -1681,7 +1714,7 @@ public static void TensorClearTest()
             }
 
             a = [.. Enumerable.Range(0, 12)];
-            t1 = a.AsTensorSpan(3, 2, 2);
+            t1 = a.AsTensorSpan([3, 2, 2]);
             tensor = Tensor.CreateUninitialized<int>([3, 2, 2], false);
             t1.CopyTo(tensor);
             tensor.Clear();
@@ -1692,7 +1725,7 @@ public static void TensorClearTest()
             }
 
             a = [.. Enumerable.Range(0, 16)];
-            t1 = a.AsTensorSpan(2, 2, 2, 2);
+            t1 = a.AsTensorSpan([2, 2, 2, 2]);
             tensor = Tensor.CreateUninitialized<int>([2, 2, 2, 2], false);
             t1.CopyTo(tensor);
             tensor.Clear();
@@ -1703,7 +1736,7 @@ public static void TensorClearTest()
             }
 
             a = [.. Enumerable.Range(0, 24)];
-            t1 = a.AsTensorSpan(3, 2, 2, 2);
+            t1 = a.AsTensorSpan([3, 2, 2, 2]);
             tensor = Tensor.CreateUninitialized<int>([3, 2, 2, 2], false);
             t1.CopyTo(tensor);
             tensor.Clear();
@@ -1715,7 +1748,7 @@ public static void TensorClearTest()
 
             // Make sure clearing a slice of a SPan doesn't clear the whole thing.
             a = [.. Enumerable.Range(0, 9)];
-            t1 = a.AsTensorSpan(3, 3);
+            t1 = a.AsTensorSpan([3, 3]);
             var spanSlice = t1.Slice(0..1, 0..3);
             spanSlice.Clear();
             var spanEnumerator = spanSlice.GetEnumerator();
@@ -1736,7 +1769,7 @@ public static void TensorClearTest()
 
             // Make sure clearing a slice from the middle of a SPan doesn't clear the whole thing.
             a = [.. Enumerable.Range(0, 9)];
-            t1 = a.AsTensorSpan(3, 3);
+            t1 = a.AsTensorSpan([3, 3]);
             spanSlice = t1.Slice(1..2, 0..3);
             spanSlice.Clear();
             spanEnumerator = spanSlice.GetEnumerator();
@@ -1757,7 +1790,7 @@ public static void TensorClearTest()
 
             // Make sure clearing a slice from the end of a SPan doesn't clear the whole thing.
             a = [.. Enumerable.Range(0, 9)];
-            t1 = a.AsTensorSpan(3, 3);
+            t1 = a.AsTensorSpan([3, 3]);
             spanSlice = t1.Slice(2..3, 0..3);
             spanSlice.Clear();
             spanEnumerator = spanSlice.GetEnumerator();
@@ -1778,7 +1811,7 @@ public static void TensorClearTest()
 
             // 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()];
-            TensorSpan<object> spanObj = o.AsTensorSpan(3, 3);
+            TensorSpan<object> spanObj = o.AsTensorSpan([3, 3]);
             spanObj.Clear();
 
             var oSpanEnumerator = spanObj.GetEnumerator();
@@ -1789,7 +1822,7 @@ public static void TensorClearTest()
 
             // Make sure clearing a slice of a SPan with references it doesn't clear the whole thing.
             o = [new object(), new object(), new object(), new object(), new object(), new object(), new object(), new object(), new object()];
-            spanObj = o.AsTensorSpan(3, 3);
+            spanObj = o.AsTensorSpan([3, 3]);
             var oSpanSlice = spanObj.Slice(0..1, 0..3);
             oSpanSlice.Clear();
             oSpanEnumerator = oSpanSlice.GetEnumerator();
@@ -1810,7 +1843,7 @@ public static void TensorClearTest()
 
             // Make sure clearing a slice of a SPan with references it doesn't clear the whole thing.
             o = [new object(), new object(), new object(), new object(), new object(), new object(), new object(), new object(), new object()];
-            spanObj = o.AsTensorSpan(3, 3);
+            spanObj = o.AsTensorSpan([3, 3]);
             oSpanSlice = spanObj.Slice(1..2, 0..3);
             oSpanSlice.Clear();
             oSpanEnumerator = oSpanSlice.GetEnumerator();
@@ -1831,7 +1864,7 @@ public static void TensorClearTest()
 
             // Make sure clearing a slice of a SPan with references it doesn't clear the whole thing.
             o = [new object(), new object(), new object(), new object(), new object(), new object(), new object(), new object(), new object()];
-            spanObj = o.AsTensorSpan(3, 3);
+            spanObj = o.AsTensorSpan([3, 3]);
             oSpanSlice = spanObj.Slice(2..3, 0..3);
             oSpanSlice.Clear();
             oSpanEnumerator = oSpanSlice.GetEnumerator();
@@ -1857,9 +1890,9 @@ public static void TensorCopyTest()
             int[] leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             int[] rightData = new int[9];
             nint[] dims = [3, 3];
-            TensorSpan<int> leftSpan = leftData.AsTensorSpan(3, 3);
+            TensorSpan<int> leftSpan = leftData.AsTensorSpan([3, 3]);
             var tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
-            TensorSpan<int> rightSpan = rightData.AsTensorSpan(3, 3);
+            TensorSpan<int> rightSpan = rightData.AsTensorSpan([3, 3]);
             leftSpan.CopyTo(tensor);
             var leftEnum = leftSpan.GetEnumerator();
             var tensorEnum = tensor.GetEnumerator();
@@ -1885,15 +1918,15 @@ public static void TensorCopyTest()
                 {
                     leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
                     dims = [15];
-                    TensorSpan<int> leftSpan = leftData.AsTensorSpan(9);
+                    TensorSpan<int> leftSpan = leftData.AsTensorSpan([9]);
                     tensor = Tensor.Create<int>(dims.AsSpan(), false);
                     leftSpan.CopyTo(tensor);
                 }
             );
 
-            Assert.Throws<ArgumentException>(() =>
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
             {
-                var l = leftData.AsTensorSpan(3, 3, 3);
+                var l = leftData.AsTensorSpan([3, 3, 3]);
                 var r = new TensorSpan<int>();
                 l.CopyTo(r);
             });
@@ -1904,10 +1937,10 @@ public static void TensorTryCopyTest()
         {
             int[] leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             int[] rightData = new int[9];
-            TensorSpan<int> leftSpan = leftData.AsTensorSpan(3, 3);
+            TensorSpan<int> leftSpan = leftData.AsTensorSpan([3, 3]);
             nint[] dims = [3, 3];
             var tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
-            TensorSpan<int> rightSpan = rightData.AsTensorSpan(3, 3);
+            TensorSpan<int> rightSpan = rightData.AsTensorSpan([3, 3]);
             var success = leftSpan.TryCopyTo(tensor);
             Assert.True(success);
             success = tensor.TryCopyTo(rightSpan);
@@ -1927,13 +1960,13 @@ public static void TensorTryCopyTest()
 
             leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             dims = [15];
-            leftSpan = leftData.AsTensorSpan(9);
+            leftSpan = leftData.AsTensorSpan([9]);
             tensor = Tensor.Create<int>(dims.AsSpan(), false);
             success = leftSpan.TryCopyTo(tensor);
             Assert.False(success);
 
             leftData = [.. Enumerable.Range(0, 27)];
-            var l = leftData.AsTensorSpan(3, 3, 3);
+            var l = leftData.AsTensorSpan([3, 3, 3]);
             dims = [2, 2];
             tensor = Tensor.Create<int>(dims.AsSpan(), false);
             var r = new TensorSpan<int>();
@@ -1955,7 +1988,7 @@ public static void TensorSliceTest()
             //Assert.Throws<ArgumentOutOfRangeException>(() => tensor.Slice(0..1));
             //Assert.Throws<ArgumentOutOfRangeException>(() => tensor.Slice(1..2));
             //Assert.Throws<ArgumentOutOfRangeException>(() => tensor.Slice(0..1, 5..6));
-            var intSpan = a.AsTensorSpan(3, 3);
+            var intSpan = a.AsTensorSpan([3, 3]);
             intSpan.CopyTo(tensor.AsTensorSpan());
 
             var sp = tensor.Slice(1..3, 1..3);
@@ -1992,7 +2025,7 @@ public static void TensorSliceTest()
 
             sp = tensor.Slice(0..1, 0..1);
             Assert.Equal(1, sp[0, 0]);
-            Assert.Throws<IndexOutOfRangeException>(() => a.AsTensorSpan(3, 3).Slice(0..1, 0..1)[0, 1]);
+            Assert.Throws<IndexOutOfRangeException>(() => a.AsTensorSpan([3, 3]).Slice(0..1, 0..1)[0, 1]);
             slice = [1];
             Assert.Equal(slice, sp.ToArray());
             enumerator = sp.GetEnumerator();
@@ -2017,7 +2050,7 @@ public static void TensorSliceTest()
             }
 
             int[] numbers = [.. Enumerable.Range(0, 27)];
-            intSpan = numbers.AsTensorSpan(3, 3, 3);
+            intSpan = numbers.AsTensorSpan([3, 3, 3]);
             tensor = Tensor.CreateUninitialized<int>([3, 3, 3], false);
             intSpan.CopyTo(tensor.AsTensorSpan());
             sp = tensor.Slice(1..2, 1..2, 1..2);
@@ -2050,7 +2083,7 @@ public static void TensorSliceTest()
             }
 
             numbers = [.. Enumerable.Range(0, 16)];
-            intSpan = numbers.AsTensorSpan(2, 2, 2, 2);
+            intSpan = numbers.AsTensorSpan([2, 2, 2, 2]);
             tensor = Tensor.CreateUninitialized<int>([2, 2, 2, 2], false);
             intSpan.CopyTo(tensor.AsTensorSpan());
             sp = tensor.Slice(1..2, 0..2, 1..2, 0..2);
@@ -2208,7 +2241,7 @@ public static void TensorUnsqueezeTest()
             Assert.Equal(0, tensor.Strides[0]);
             Assert.Equal(0, tensor.Strides[1]);
 
-            tensor = Tensor.Create<int>([2], false);
+            tensor = Tensor.Create<int>((ReadOnlySpan<nint>)[2], false);
             Assert.Equal(1, tensor.Rank);
             Assert.Equal(2, tensor.Lengths[0]);
             Assert.Equal(1, tensor.Strides[0]);
@@ -2217,7 +2250,7 @@ public static void TensorUnsqueezeTest()
             Assert.Equal(2, tensor.Rank);
             Assert.Equal(1, tensor.Lengths[0]);
             Assert.Equal(2, tensor.Lengths[1]);
-            Assert.Equal(2, tensor.Strides[0]);
+            Assert.Equal(0, tensor.Strides[0]);
             Assert.Equal(1, tensor.Strides[1]);
 
             tensor = Tensor.Unsqueeze(tensor, 0);
@@ -2225,8 +2258,8 @@ public static void TensorUnsqueezeTest()
             Assert.Equal(1, tensor.Lengths[0]);
             Assert.Equal(1, tensor.Lengths[1]);
             Assert.Equal(2, tensor.Lengths[2]);
-            Assert.Equal(2, tensor.Strides[0]);
-            Assert.Equal(2, tensor.Strides[1]);
+            Assert.Equal(0, tensor.Strides[0]);
+            Assert.Equal(0, tensor.Strides[1]);
             Assert.Equal(1, tensor.Strides[2]);
 
             tensor = Tensor.Unsqueeze(tensor, 0);
@@ -2235,12 +2268,12 @@ public static void TensorUnsqueezeTest()
             Assert.Equal(1, tensor.Lengths[1]);
             Assert.Equal(1, tensor.Lengths[2]);
             Assert.Equal(2, tensor.Lengths[3]);
-            Assert.Equal(2, tensor.Strides[0]);
-            Assert.Equal(2, tensor.Strides[1]);
-            Assert.Equal(2, tensor.Strides[2]);
+            Assert.Equal(0, tensor.Strides[0]);
+            Assert.Equal(0, tensor.Strides[1]);
+            Assert.Equal(0, tensor.Strides[2]);
             Assert.Equal(1, tensor.Strides[3]);
 
-            tensor = Tensor.Create<int>([2], false);
+            tensor = Tensor.Create<int>((ReadOnlySpan<nint>)[2], false);
             Assert.Equal(1, tensor.Rank);
             Assert.Equal(2, tensor.Lengths[0]);
 
@@ -2249,7 +2282,7 @@ public static void TensorUnsqueezeTest()
             Assert.Equal(2, tensor.Lengths[0]);
             Assert.Equal(1, tensor.Lengths[1]);
 
-            tensor = Tensor.Create<int>([2], false);
+            tensor = Tensor.Create<int>((ReadOnlySpan<nint>)[2], false);
             Assert.Equal(1, tensor.Rank);
             Assert.Equal(2, tensor.Lengths[0]);
 
@@ -2265,15 +2298,15 @@ public static void TensorUnsqueezeTest()
         [Fact]
         public void TensorGreaterThanTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             Tensor<bool> result = Tensor.GreaterThan(tensor1.AsReadOnlyTensorSpan(), tensor2);
 
             Assert.Equal(new bool[] { false, false, true }, result.ToArray());
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.GreaterThan(tensor1.AsReadOnlyTensorSpan(), tensor2);
 
@@ -2291,15 +2324,15 @@ public void TensorGreaterThanTest()
         [Fact]
         public void TensorGreaterThanOrEqualTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             Tensor<bool> result = Tensor.GreaterThanOrEqual(tensor1.AsReadOnlyTensorSpan(), tensor2);
 
             Assert.Equal(new bool[] { false, true, true }, result.ToArray());
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.GreaterThanOrEqual(tensor1.AsReadOnlyTensorSpan(), tensor2);
 
@@ -2317,14 +2350,14 @@ public void TensorGreaterThanOrEqualTest()
         [Fact]
         public void TensorGreaterThanAllTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             bool result = Tensor.GreaterThanAll(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.False(result);
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.GreaterThanAll(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.False(result);
@@ -2345,14 +2378,14 @@ public void TensorGreaterThanAllTest()
         [Fact]
         public void TensorGreaterThanOrEqualAllTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             bool result = Tensor.GreaterThanOrEqualAll(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.False(result);
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.GreaterThanOrEqualAll(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.True(result);
@@ -2373,14 +2406,14 @@ public void TensorGreaterThanOrEqualAllTest()
         [Fact]
         public void TensorGreaterThanAnyTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             bool result = Tensor.GreaterThanAny(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.True(result);
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.GreaterThanAny(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.True(result);
@@ -2404,14 +2437,14 @@ public void TensorGreaterThanAnyTest()
         [Fact]
         public void TensorGreaterThanOrEqualAnyTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             bool result = Tensor.GreaterThanOrEqualAny(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.True(result);
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.GreaterThanOrEqualAny(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.True(result);
@@ -2435,15 +2468,15 @@ public void TensorGreaterThanOrEqualAnyTest()
         [Fact]
         public void TensorLessThanTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             Tensor<bool> result = Tensor.LessThan(tensor1.AsReadOnlyTensorSpan(), tensor2);
 
             Assert.Equal(new bool[] { true, false, false }, result.ToArray());
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.LessThan(tensor1.AsReadOnlyTensorSpan(), tensor2);
 
@@ -2461,15 +2494,15 @@ public void TensorLessThanTest()
         [Fact]
         public void TensorLessThanOrEqualTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             Tensor<bool> result = Tensor.LessThanOrEqual(tensor1.AsReadOnlyTensorSpan(), tensor2);
 
             Assert.Equal(new bool[] { true, true, false }, result.ToArray());
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.LessThanOrEqual(tensor1.AsReadOnlyTensorSpan(), tensor2);
 
@@ -2487,14 +2520,14 @@ public void TensorLessThanOrEqualTest()
         [Fact]
         public void TensorLessThanAllTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             bool result = Tensor.LessThanAll(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.False(result);
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.LessThanAll(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.False(result);
@@ -2515,14 +2548,14 @@ public void TensorLessThanAllTest()
         [Fact]
         public void TensorLessThanAnyTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             bool result = Tensor.LessThanAny(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.True(result);
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.LessThanAny(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.False(result);
@@ -2546,14 +2579,14 @@ public void TensorLessThanAnyTest()
         [Fact]
         public void TensorLessThanOrEqualAllTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             bool result = Tensor.LessThanOrEqualAll(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.False(result);
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.LessThanOrEqualAll(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.False(result);
@@ -2577,14 +2610,14 @@ public void TensorLessThanOrEqualAllTest()
         [Fact]
         public void TensorLessThanOrEqualAnyTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3], false);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, [3], false);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 2, 2, 2 }, lengths: [3]);
 
             bool result = Tensor.LessThanOrEqualAny(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.True(result);
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, [2, 2], false);
-            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, [2, 2], false);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4 }, lengths: [2, 2]);
+            tensor2 = Tensor.Create<int>(new int[] { 0, 2, 2, 3 }, lengths: [2, 2]);
 
             result = Tensor.LessThanOrEqualAny(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.True(result);
@@ -2608,8 +2641,8 @@ public void TensorLessThanOrEqualAnyTest()
         [Fact]
         public void TensorEqualsTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3]);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3]);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
 
             Tensor<bool> result = Tensor.Equals(tensor1.AsReadOnlyTensorSpan(), tensor2);
 
@@ -2627,8 +2660,8 @@ public void TensorEqualsTest()
 
             Assert.Equal(new bool[] { false, false, true }, result.ToArray());
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4, 5, 6 }, [2, 3]);
-            tensor2 = Tensor.Create<int>(new int[] { 4, 5, 6 }, [3]);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4, 5, 6 }, lengths: [2, 3]);
+            tensor2 = Tensor.Create<int>(new int[] { 4, 5, 6 }, lengths: [3]);
 
             result = Tensor.Equals(tensor1.AsReadOnlyTensorSpan(), tensor2);
 
@@ -2638,8 +2671,8 @@ public void TensorEqualsTest()
         [Fact]
         public void TensorEqualsAllTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3]);
-            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3]);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<int> tensor2 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
 
             bool result = Tensor.EqualsAll(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.True(result);
@@ -2653,17 +2686,17 @@ public void TensorEqualsAllTest()
             result = Tensor.EqualsAll(tensor1.AsReadOnlyTensorSpan(), 3);
             Assert.False(result);
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 1, 1 }, [3]);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 1, 1 }, lengths: [3]);
             result = Tensor.EqualsAll(tensor1.AsReadOnlyTensorSpan(), 1);
             Assert.True(result);
 
-            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4, 5, 6 }, [2, 3]);
-            tensor2 = Tensor.Create<int>(new int[] { 4, 5, 6 }, [3]);
+            tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3, 4, 5, 6 }, lengths: [2, 3]);
+            tensor2 = Tensor.Create<int>(new int[] { 4, 5, 6 }, lengths: [3]);
 
             result = Tensor.EqualsAll(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.False(result);
 
-            tensor1 = Tensor.Create<int>(new int[] { 4, 5, 6, 4, 5, 6 }, [2, 3]);
+            tensor1 = Tensor.Create<int>(new int[] { 4, 5, 6, 4, 5, 6 }, lengths: [2, 3]);
             result = Tensor.EqualsAll(tensor1.AsReadOnlyTensorSpan(), tensor2);
             Assert.True(result);
         }
@@ -2671,9 +2704,9 @@ public void TensorEqualsAllTest()
         [Fact]
         public void TensorFilteredUpdateTest()
         {
-            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, [3]);
-            Tensor<bool> filter = Tensor.Create<bool>(new bool[] { true, false, false }, [3]);
-            Tensor<int> replace = Tensor.Create<int>(new int[] { -1, -1, -1 }, [3]);
+            Tensor<int> tensor1 = Tensor.Create<int>(new int[] { 1, 2, 3 }, lengths: [3]);
+            Tensor<bool> filter = Tensor.Create<bool>(new bool[] { true, false, false }, lengths: [3]);
+            Tensor<int> replace = Tensor.Create<int>(new int[] { -1, -1, -1 }, lengths: [3]);
 
             Tensor.FilteredUpdate(tensor1.AsTensorSpan(), filter, 2);
             Assert.Equal(new int[] { 2, 2, 3 }, tensor1.ToArray());
@@ -2681,7 +2714,7 @@ public void TensorFilteredUpdateTest()
             Tensor.FilteredUpdate(tensor1.AsTensorSpan(), filter, replace);
             Assert.Equal(new int[] { -1, 2, 3 }, tensor1.ToArray());
 
-            filter = Tensor.Create<bool>(new bool[] { true, true, true}, [3]);
+            filter = Tensor.Create<bool>(new bool[] { true, true, true}, lengths: [3]);
             Tensor.FilteredUpdate(tensor1.AsTensorSpan(), filter, replace);
             Assert.Equal(new int[] { -1, -1, -1 }, tensor1.ToArray());
         }
@@ -2689,7 +2722,7 @@ public void TensorFilteredUpdateTest()
         [Fact]
         public void TensorObjectFillTests()
         {
-            ITensor tensor = (ITensor)new Tensor<int>(new int[4], new nint[] { 2, 2 }, 0);
+            ITensor tensor = (ITensor)new Tensor<int>(new int[4], new nint[] { 2, 2 });
             tensor.Fill(5);
 
             Assert.Equal(5, tensor[0, 0]);
@@ -2710,7 +2743,7 @@ public void TensorObjectFillTests()
         [Fact]
         public void TensorObjectIndexerTests()
         {
-            ITensor tensor = new Tensor<int>(new int[] { 1, 2, 3, 4 }, new nint[] { 2, 2 }, 0);
+            ITensor tensor = new Tensor<int>(new int[] { 1, 2, 3, 4 }, new nint[] { 2, 2 });
 
             Assert.Equal(1, tensor[new nint[] { 0, 0 }]);
             Assert.Equal(2, tensor[new nint[] { 0, 1 }]);
@@ -2741,7 +2774,7 @@ public void TensorObjectIndexerTests()
         [Fact]
         public void TensorGetPinnedHandleTests()
         {
-            Tensor<int> tensor = new Tensor<int>(new int[] { 1, 2, 3, 4 }, new nint[] { 2, 2 }, 0);
+            Tensor<int> tensor = new Tensor<int>(new int[] { 1, 2, 3, 4 }, new nint[] { 2, 2 });
 
             using MemoryHandle handle = tensor.GetPinnedHandle();
             unsafe

From d154e4793a80515bb4e77c35d08a7cf13ff13977 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 25 Apr 2025 08:44:15 -0700
Subject: [PATCH 5/5] [release/10.0-preview4] [Test Only] Fix Idn failing tests
 (#115021)

* Fix Idn failing tests

* Minor fix

---------

Co-authored-by: Tarek Mahmoud Sayed <tarekms@microsoft.com>
Co-authored-by: Tarek Mahmoud Sayed <10833894+tarekgh@users.noreply.github.com>
---
 .../IdnMapping/Data/Factory.cs                                | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/libraries/System.Runtime/tests/System.Globalization.Extensions.Tests/IdnMapping/Data/Factory.cs b/src/libraries/System.Runtime/tests/System.Globalization.Extensions.Tests/IdnMapping/Data/Factory.cs
index c2610eb092ced3..f1d96fc1c94097 100644
--- a/src/libraries/System.Runtime/tests/System.Globalization.Extensions.Tests/IdnMapping/Data/Factory.cs
+++ b/src/libraries/System.Runtime/tests/System.Globalization.Extensions.Tests/IdnMapping/Data/Factory.cs
@@ -28,7 +28,7 @@ private static Stream GetIdnaTestTxt()
             string fileName = null;
             if (PlatformDetection.ICUVersion >= new Version(76, 0))
                 fileName = "IdnaTest_16.txt";
-            else if (PlatformDetection.ICUVersion >= new Version(74, 0))
+            else if (PlatformDetection.ICUVersion >= new Version(72, 0))
                 fileName = "IdnaTest_15_1.txt";
             else if (PlatformDetection.ICUVersion >= new Version(66, 0) || PlatformDetection.IsHybridGlobalizationOnApplePlatform)
                 fileName = "IdnaTest_13.txt";
@@ -67,7 +67,7 @@ private static IConformanceIdnaTest GetConformanceIdnaTest(string line, int line
         {
             if (PlatformDetection.ICUVersion >= new Version(76, 0))
                 return new Unicode_16_0_IdnaTest(line, lineCount);
-            else if (PlatformDetection.ICUVersion >= new Version(74, 0))
+            else if (PlatformDetection.ICUVersion >= new Version(72, 0))
                 return new Unicode_15_1_IdnaTest(line, lineCount);
             else if (PlatformDetection.ICUVersion >= new Version(66, 0) || PlatformDetection.IsHybridGlobalizationOnApplePlatform)
                 return new Unicode_13_0_IdnaTest(line, lineCount);