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 c64250c0151164..cb2854ca7a2842 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
@@ -199,15 +199,21 @@ public static ref readonly TensorSpan<T> Concatenate<T>(scoped ReadOnlySpan<Tens
         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_InvalidDimension();
+            }
 
             // Calculate total space needed.
             nint totalLength = 0;
             for (int i = 0; i < tensors.Length; i++)
+            {
                 totalLength += tensors[i].FlattenedLength;
+            }
 
             // If axis != -1, make sure all dimensions except the one to concatenate on match.
             if (dimension != -1)
@@ -217,13 +223,17 @@ public static ref readonly TensorSpan<T> ConcatenateOnDimension<T>(int dimension
                 for (int i = 1; i < tensors.Length; i++)
                 {
                     if (rank != tensors[i].Rank)
+                    {
                         ThrowHelper.ThrowArgument_InvalidConcatenateShape();
+                    }
                     for (int j = 0; j < rank; j++)
                     {
                         if (j != dimension)
                         {
                             if (tensors[0].Lengths[j] != tensors[i].Lengths[j])
+                            {
                                 ThrowHelper.ThrowArgument_InvalidConcatenateShape();
+                            }
                         }
                     }
                     sumOfAxis += tensors[i].Lengths[dimension];
@@ -235,10 +245,39 @@ public static ref readonly TensorSpan<T> ConcatenateOnDimension<T>(int dimension
                 lengths[dimension] = sumOfAxis;
 
                 if (!TensorShape.AreLengthsTheSame(destination.Lengths, lengths))
+                {
                     ThrowHelper.ThrowArgument_DimensionsNotSame(nameof(destination));
+                }
             }
-            Span<T> dstSpan = MemoryMarshal.CreateSpan(ref destination._reference, (int)totalLength);
 
+            if (!destination.IsDense)
+            {
+                // For non-dense destinations, concatenate into a temporary dense buffer,
+                // then copy element-by-element to respect the destination's stride layout.
+                T[] tempBuffer = ArrayPool<T>.Shared.Rent((int)totalLength);
+                try
+                {
+                    Span<T> tempSpan = tempBuffer.AsSpan(0, (int)totalLength);
+                    ConcatenateOnDimensionToSpan(dimension, tensors, destination, tempSpan);
+                    ReadOnlyTensorSpan<T> tempTensor = new ReadOnlyTensorSpan<T>(tempBuffer, 0, destination.Lengths, []);
+                    TensorOperation.Invoke<TensorOperation.CopyTo<T>, T, T>(tempTensor, destination);
+                }
+                finally
+                {
+                    ArrayPool<T>.Shared.Return(tempBuffer);
+                }
+            }
+            else
+            {
+                Span<T> dstSpan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength);
+                ConcatenateOnDimensionToSpan(dimension, tensors, destination, dstSpan);
+            }
+
+            return ref destination;
+        }
+
+        private static void ConcatenateOnDimensionToSpan<T>(int dimension, scoped ReadOnlySpan<Tensor<T>> tensors, in TensorSpan<T> destination, Span<T> dstSpan)
+        {
             if (dimension is 0 or -1)
             {
                 for (int i = 0; i < tensors.Length; i++)
@@ -273,7 +312,6 @@ public static ref readonly TensorSpan<T> ConcatenateOnDimension<T>(int dimension
                 }
                 rentedBuffer.Dispose();
             }
-            return ref destination;
         }
 
         private static nint CalculateCopyLength(ReadOnlySpan<nint> lengths, int startingAxis)
@@ -347,14 +385,29 @@ public static Tensor<T> CreateFromShapeUninitialized<T>(scoped ReadOnlySpan<nint
         /// <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(ref destination._reference, (int)destination._shape.LinearLength);
             random ??= Random.Shared;
 
-            for (int i = 0; i < span.Length; i++)
+            if (destination.IsDense)
             {
-                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));
+                Span<T> span = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength);
+
+                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));
+                }
+            }
+            else
+            {
+                TensorSpan<T>.Enumerator enumerator = destination.GetEnumerator();
+
+                while (enumerator.MoveNext())
+                {
+                    double u1 = 1.0 - random.NextDouble();
+                    double u2 = 1.0 - random.NextDouble();
+                    enumerator.Current = T.CreateChecked(Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2));
+                }
             }
 
             return ref destination;
@@ -370,10 +423,25 @@ public static ref readonly TensorSpan<T> FillGaussianNormalDistribution<T>(in Te
         /// <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(ref destination._reference, (int)destination._shape.LinearLength);
             random ??= Random.Shared;
-            for (int i = 0; i < span.Length; i++)
-                span[i] = T.CreateChecked(random.NextDouble());
+
+            if (destination.IsDense)
+            {
+                Span<T> span = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength);
+                for (int i = 0; i < span.Length; i++)
+                {
+                    span[i] = T.CreateChecked(random.NextDouble());
+                }
+            }
+            else
+            {
+                TensorSpan<T>.Enumerator enumerator = destination.GetEnumerator();
+
+                while (enumerator.MoveNext())
+                {
+                    enumerator.Current = T.CreateChecked(random.NextDouble());
+                }
+            }
 
             return ref destination;
         }
@@ -1549,12 +1617,33 @@ 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 = Create(values, lengths, []);
-            ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref tensor.AsTensorSpan()._reference, tensor._start), tensor._values.Length - tensor._start);
-            Span<T> ospan = MemoryMarshal.CreateSpan(ref output.AsTensorSpan()._reference, (int)output.FlattenedLength);
-            if (newSize >= span.Length)
-                span.CopyTo(ospan);
+
+            if (tensor.IsDense)
+            {
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref tensor.AsTensorSpan()._reference, tensor._start), 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);
+                }
+            }
             else
-                span.Slice(0, ospan.Length).CopyTo(ospan);
+            {
+                nint copyLength = Math.Min(tensor.FlattenedLength, newSize);
+                ReadOnlyTensorSpan<T>.Enumerator enumerator = tensor.AsReadOnlyTensorSpan().GetEnumerator();
+                Span<T> ospan = MemoryMarshal.CreateSpan(ref output.AsTensorSpan()._reference, (int)output.FlattenedLength);
+
+                for (nint i = 0; i < copyLength; i++)
+                {
+                    bool moved = enumerator.MoveNext();
+                    Debug.Assert(moved);
+                    ospan[(int)i] = enumerator.Current;
+                }
+            }
 
             return output;
         }
@@ -1589,12 +1678,33 @@ public static void ResizeTo<T>(scoped in TensorSpan<T> tensor, in TensorSpan<T>
         /// <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);
+            if (tensor.IsDense && destination.IsDense)
+            {
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref tensor._reference, (int)tensor.FlattenedLength);
+                Span<T> ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength);
+                if (ospan.Length >= span.Length)
+                {
+                    span.CopyTo(ospan);
+                }
+                else
+                {
+                    span.Slice(0, ospan.Length).CopyTo(ospan);
+                }
+            }
             else
-                span.Slice(0, ospan.Length).CopyTo(ospan);
+            {
+                nint copyLength = Math.Min(tensor.FlattenedLength, destination.FlattenedLength);
+                ReadOnlyTensorSpan<T>.Enumerator srcEnumerator = tensor.GetEnumerator();
+                TensorSpan<T>.Enumerator dstEnumerator = destination.GetEnumerator();
+
+                for (nint i = 0; i < copyLength; i++)
+                {
+                    bool srcMoved = srcEnumerator.MoveNext();
+                    bool dstMoved = dstEnumerator.MoveNext();
+                    Debug.Assert(srcMoved && dstMoved);
+                    dstEnumerator.Current = srcEnumerator.Current;
+                }
+            }
         }
         #endregion
 
@@ -1684,10 +1794,7 @@ public static ref readonly TensorSpan<T> ReverseDimension<T>(scoped in ReadOnlyT
         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));
+            return ((ReadOnlyTensorSpan<T>)tensor).SequenceEqual(other);
         }
 
         /// <summary>
@@ -1696,10 +1803,32 @@ public static bool SequenceEqual<T>(this scoped in TensorSpan<T> tensor, scoped
         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));
+            if (tensor.FlattenedLength != other.FlattenedLength
+                || !tensor.Lengths.SequenceEqual(other.Lengths))
+            {
+                return false;
+            }
+
+            if (tensor.IsDense && other.IsDense)
+            {
+                return MemoryMarshal.CreateReadOnlySpan(in tensor.GetPinnableReference(), (int)tensor.FlattenedLength).SequenceEqual(MemoryMarshal.CreateReadOnlySpan(in other.GetPinnableReference(), (int)other.FlattenedLength));
+            }
+
+            ReadOnlyTensorSpan<T>.Enumerator enumerator1 = tensor.GetEnumerator();
+            ReadOnlyTensorSpan<T>.Enumerator enumerator2 = other.GetEnumerator();
+
+            while (enumerator1.MoveNext())
+            {
+                bool moved = enumerator2.MoveNext();
+                Debug.Assert(moved);
+
+                if (!(enumerator1.Current?.Equals(enumerator2.Current) ?? (object?)enumerator2.Current is null))
+                {
+                    return false;
+                }
+            }
+
+            return true;
         }
         #endregion
 
@@ -3528,8 +3657,28 @@ public static ref readonly TensorSpan<int> ILogB<T>(scoped in ReadOnlyTensorSpan
         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);
+            if (x.IsDense)
+            {
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x.FlattenedLength);
+                return TensorPrimitives.IndexOfMax(span);
+            }
+
+            return IndexOfMaxFallback(x);
+        }
+
+        private static nint IndexOfMaxFallback<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            T[] flat = ArrayPool<T>.Shared.Rent((int)x.FlattenedLength);
+            try
+            {
+                x.FlattenTo(flat);
+                return TensorPrimitives.IndexOfMax<T>(flat.AsSpan(0, (int)x.FlattenedLength));
+            }
+            finally
+            {
+                ArrayPool<T>.Shared.Return(flat);
+            }
         }
 
         #endregion
@@ -3540,8 +3689,28 @@ public static nint IndexOfMax<T>(scoped in ReadOnlyTensorSpan<T> x)
         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);
+            if (x.IsDense)
+            {
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x.FlattenedLength);
+                return TensorPrimitives.IndexOfMaxMagnitude(span);
+            }
+
+            return IndexOfMaxMagnitudeFallback(x);
+        }
+
+        private static nint IndexOfMaxMagnitudeFallback<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            T[] flat = ArrayPool<T>.Shared.Rent((int)x.FlattenedLength);
+            try
+            {
+                x.FlattenTo(flat);
+                return TensorPrimitives.IndexOfMaxMagnitude<T>(flat.AsSpan(0, (int)x.FlattenedLength));
+            }
+            finally
+            {
+                ArrayPool<T>.Shared.Return(flat);
+            }
         }
         #endregion
 
@@ -3551,8 +3720,28 @@ public static nint IndexOfMaxMagnitude<T>(scoped in ReadOnlyTensorSpan<T> x)
         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);
+            if (x.IsDense)
+            {
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x.FlattenedLength);
+                return TensorPrimitives.IndexOfMin(span);
+            }
+
+            return IndexOfMinFallback(x);
+        }
+
+        private static nint IndexOfMinFallback<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            T[] flat = ArrayPool<T>.Shared.Rent((int)x.FlattenedLength);
+            try
+            {
+                x.FlattenTo(flat);
+                return TensorPrimitives.IndexOfMin<T>(flat.AsSpan(0, (int)x.FlattenedLength));
+            }
+            finally
+            {
+                ArrayPool<T>.Shared.Return(flat);
+            }
         }
         #endregion
 
@@ -3564,8 +3753,28 @@ public static nint IndexOfMin<T>(scoped in ReadOnlyTensorSpan<T> x)
         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);
+            if (x.IsDense)
+            {
+                ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref x._reference, (int)x.FlattenedLength);
+                return TensorPrimitives.IndexOfMinMagnitude(span);
+            }
+
+            return IndexOfMinMagnitudeFallback(x);
+        }
+
+        private static nint IndexOfMinMagnitudeFallback<T>(scoped in ReadOnlyTensorSpan<T> x)
+            where T : INumber<T>
+        {
+            T[] flat = ArrayPool<T>.Shared.Rent((int)x.FlattenedLength);
+            try
+            {
+                x.FlattenTo(flat);
+                return TensorPrimitives.IndexOfMinMagnitude<T>(flat.AsSpan(0, (int)x.FlattenedLength));
+            }
+            finally
+            {
+                ArrayPool<T>.Shared.Return(flat);
+            }
         }
         #endregion
 
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
index f3e280f67587b3..408f767205e3e8 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
@@ -785,6 +785,383 @@ public static void TensorCosineSimilarityTests()
         //    Assert.Throws<Exception>(() => Tensor.SequenceEqual(t0, t1));
         //}
 
+        /// <summary>
+        /// Provides test cases of (dataArray, shape, strides) for creating non-dense tensor spans.
+        /// Each case has known logical elements that differ from the raw buffer layout.
+        /// </summary>
+        public static IEnumerable<object[]> NonDenseTensorData()
+        {
+            // 2x2 from 1D array with stride gap: logical elements are [10, 20, 30, 40]
+            yield return new object[] { new int[] { 10, 20, 99, 99, 30, 40, 99, 99 }, new nint[] { 2, 2 }, new nint[] { 4, 1 }, new int[] { 10, 20, 30, 40 } };
+            // 2x3 from 1D array with stride gap: logical elements are [1, 2, 3, 4, 5, 6]
+            yield return new object[] { new int[] { 1, 2, 3, 99, 4, 5, 6, 99 }, new nint[] { 2, 3 }, new nint[] { 4, 1 }, new int[] { 1, 2, 3, 4, 5, 6 } };
+            // 3x2 from 1D array with stride gap: logical elements are [1, 2, 3, 4, 5, 6]
+            yield return new object[] { new int[] { 1, 2, 99, 3, 4, 99, 5, 6, 99 }, new nint[] { 3, 2 }, new nint[] { 3, 1 }, new int[] { 1, 2, 3, 4, 5, 6 } };
+            // 1x2 from 1D array with larger stride gap
+            yield return new object[] { new int[] { 42, 99, 99, 99, 7, 99, 99, 99 }, new nint[] { 2 }, new nint[] { 4 }, new int[] { 42, 7 } };
+        }
+
+        [Theory]
+        [MemberData(nameof(NonDenseTensorData))]
+        public static void TensorSequenceEqualNonDenseTests(int[] data, nint[] shape, nint[] strides, int[] expectedLogical)
+        {
+            var ts1 = new ReadOnlyTensorSpan<int>(data, shape, strides);
+            Assert.False(ts1.IsDense);
+
+            // Non-dense vs non-dense with same logical elements but different gap values
+            int[] data2 = (int[])data.Clone();
+            for (int i = 0; i < data2.Length; i++)
+            {
+                if (data2[i] == 99)
+                {
+                    data2[i] = 77;
+                }
+            }
+            var ts2 = new ReadOnlyTensorSpan<int>(data2, shape, strides);
+            Assert.False(ts2.IsDense);
+            Assert.True(ts1.SequenceEqual(ts2));
+
+            // Non-dense vs dense with same logical elements
+            var tsDense = new ReadOnlyTensorSpan<int>(expectedLogical, shape);
+            Assert.True(tsDense.IsDense);
+            Assert.True(ts1.SequenceEqual(tsDense));
+            Assert.True(tsDense.SequenceEqual(ts1));
+
+            // TensorSpan overload also works
+            var tspan1 = new TensorSpan<int>(data, shape, strides);
+            Assert.True(tspan1.SequenceEqual(ts2));
+
+            // Differing logical element should return false
+            int[] data3 = (int[])data.Clone();
+            data3[0] = data3[0] + 1;
+            var ts3 = new ReadOnlyTensorSpan<int>(data3, shape, strides);
+            Assert.False(ts1.SequenceEqual(ts3));
+        }
+
+        /// <summary>
+        /// Computes the set of buffer offsets that correspond to logical elements in a non-dense tensor.
+        /// </summary>
+        private static HashSet<int> ComputeLogicalOffsets(nint[] shape, nint[] strides, nint flattenedLength)
+        {
+            HashSet<int> logicalOffsets = new HashSet<int>();
+            for (nint i = 0; i < flattenedLength; i++)
+            {
+                nint offset = 0;
+                nint remaining = i;
+                for (int d = shape.Length - 1; d >= 0; d--)
+                {
+                    nint dimIndex = remaining % shape[d];
+                    remaining /= shape[d];
+                    offset += dimIndex * strides[d];
+                }
+                logicalOffsets.Add((int)offset);
+            }
+            return logicalOffsets;
+        }
+
+        [Theory]
+        [MemberData(nameof(NonDenseTensorData))]
+        public static void TensorFillGaussianNormalDistributionNonDenseTests(int[] data, nint[] shape, nint[] strides, int[] expectedLogical)
+        {
+            _ = expectedLogical;
+            double[] dblData = new double[data.Length];
+            var ts = new TensorSpan<double>(dblData, shape, strides);
+            Assert.False(ts.IsDense);
+
+            Tensor.FillGaussianNormalDistribution(ts, new Random(42));
+
+            // All logical elements should be filled
+            foreach (double val in ts)
+            {
+                Assert.NotEqual(0.0, val);
+            }
+
+            // Gap positions should remain untouched (zero)
+            HashSet<int> logicalOffsets = ComputeLogicalOffsets(shape, strides, ts.FlattenedLength);
+            for (int i = 0; i < dblData.Length; i++)
+            {
+                if (!logicalOffsets.Contains(i))
+                {
+                    Assert.Equal(0.0, dblData[i]);
+                }
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(NonDenseTensorData))]
+        public static void TensorFillUniformDistributionNonDenseTests(int[] data, nint[] shape, nint[] strides, int[] expectedLogical)
+        {
+            _ = expectedLogical;
+            double[] dblData = new double[data.Length];
+            var ts = new TensorSpan<double>(dblData, shape, strides);
+            Assert.False(ts.IsDense);
+
+            Tensor.FillUniformDistribution(ts, new Random(42));
+
+            // All logical elements should be filled with values in [0, 1)
+            foreach (double val in ts)
+            {
+                Assert.InRange(val, 0.0, 1.0);
+                Assert.NotEqual(0.0, val);
+            }
+
+            // Gap positions should remain untouched (zero)
+            HashSet<int> logicalOffsets = ComputeLogicalOffsets(shape, strides, ts.FlattenedLength);
+            for (int i = 0; i < dblData.Length; i++)
+            {
+                if (!logicalOffsets.Contains(i))
+                {
+                    Assert.Equal(0.0, dblData[i]);
+                }
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(NonDenseTensorData))]
+        public static void TensorIndexOfMaxNonDenseTests(int[] data, nint[] shape, nint[] strides, int[] expectedLogical)
+        {
+            _ = expectedLogical;
+            // Set a known max in the data at logical position
+            int[] testData = (int[])data.Clone();
+            // First, set all logical elements to small values
+            nint flatLen = 1;
+            foreach (nint s in shape)
+            {
+                flatLen *= s;
+            }
+
+            // Place the maximum value at the last logical position
+            nint lastOffset = 0;
+            nint rem = flatLen - 1;
+            for (int d = shape.Length - 1; d >= 0; d--)
+            {
+                nint dimIndex = rem % shape[d];
+                rem /= shape[d];
+                lastOffset += dimIndex * strides[d];
+            }
+            testData[(int)lastOffset] = 9999;
+
+            var ts = new ReadOnlyTensorSpan<int>(testData, shape, strides);
+            Assert.False(ts.IsDense);
+
+            nint idx = Tensor.IndexOfMax(ts);
+            Assert.Equal(flatLen - 1, idx);
+        }
+
+        [Theory]
+        [MemberData(nameof(NonDenseTensorData))]
+        public static void TensorIndexOfMinNonDenseTests(int[] data, nint[] shape, nint[] strides, int[] expectedLogical)
+        {
+            _ = expectedLogical;
+            // Set all logical elements to positive values, then put the minimum at the last logical position
+            int[] testData = new int[data.Length];
+            Array.Fill(testData, 50);
+
+            nint flatLen = 1;
+            foreach (nint s in shape)
+            {
+                flatLen *= s;
+            }
+
+            // Set all logical positions to values > 0
+            for (nint i = 0; i < flatLen; i++)
+            {
+                nint offset = 0;
+                nint remaining = i;
+                for (int d = shape.Length - 1; d >= 0; d--)
+                {
+                    nint dimIndex = remaining % shape[d];
+                    remaining /= shape[d];
+                    offset += dimIndex * strides[d];
+                }
+                testData[(int)offset] = (int)(i + 10);
+            }
+
+            // Place the minimum at the last logical position
+            nint lastOffset = 0;
+            nint rem = flatLen - 1;
+            for (int d = shape.Length - 1; d >= 0; d--)
+            {
+                nint dimIndex = rem % shape[d];
+                rem /= shape[d];
+                lastOffset += dimIndex * strides[d];
+            }
+            testData[(int)lastOffset] = -1;
+
+            var ts = new ReadOnlyTensorSpan<int>(testData, shape, strides);
+            Assert.False(ts.IsDense);
+
+            nint idx = Tensor.IndexOfMin(ts);
+            Assert.Equal(flatLen - 1, idx);
+        }
+
+        [Theory]
+        [MemberData(nameof(NonDenseTensorData))]
+        public static void TensorIndexOfMaxMagnitudeNonDenseTests(int[] data, nint[] shape, nint[] strides, int[] expectedLogical)
+        {
+            _ = expectedLogical;
+            int[] testData = new int[data.Length];
+            Array.Fill(testData, 1);
+
+            nint flatLen = 1;
+            foreach (nint s in shape)
+            {
+                flatLen *= s;
+            }
+
+            // Set all logical positions to small values
+            for (nint i = 0; i < flatLen; i++)
+            {
+                nint offset = 0;
+                nint remaining = i;
+                for (int d = shape.Length - 1; d >= 0; d--)
+                {
+                    nint dimIndex = remaining % shape[d];
+                    remaining /= shape[d];
+                    offset += dimIndex * strides[d];
+                }
+                testData[(int)offset] = (int)(i + 1);
+            }
+
+            // Place the max magnitude at the last logical position
+            nint lastOffset = 0;
+            nint rem = flatLen - 1;
+            for (int d = shape.Length - 1; d >= 0; d--)
+            {
+                nint dimIndex = rem % shape[d];
+                rem /= shape[d];
+                lastOffset += dimIndex * strides[d];
+            }
+            testData[(int)lastOffset] = -9999;
+
+            var ts = new ReadOnlyTensorSpan<int>(testData, shape, strides);
+            Assert.False(ts.IsDense);
+
+            nint idx = Tensor.IndexOfMaxMagnitude(ts);
+            Assert.Equal(flatLen - 1, idx);
+        }
+
+        [Theory]
+        [MemberData(nameof(NonDenseTensorData))]
+        public static void TensorIndexOfMinMagnitudeNonDenseTests(int[] data, nint[] shape, nint[] strides, int[] expectedLogical)
+        {
+            _ = expectedLogical;
+            int[] testData = new int[data.Length];
+            Array.Fill(testData, 100);
+
+            nint flatLen = 1;
+            foreach (nint s in shape)
+            {
+                flatLen *= s;
+            }
+
+            // Set all logical positions to large magnitude values
+            for (nint i = 0; i < flatLen; i++)
+            {
+                nint offset = 0;
+                nint remaining = i;
+                for (int d = shape.Length - 1; d >= 0; d--)
+                {
+                    nint dimIndex = remaining % shape[d];
+                    remaining /= shape[d];
+                    offset += dimIndex * strides[d];
+                }
+                testData[(int)offset] = (int)(i + 100);
+            }
+
+            // Place the min magnitude at the first logical position
+            testData[0] = 0;
+
+            var ts = new ReadOnlyTensorSpan<int>(testData, shape, strides);
+            Assert.False(ts.IsDense);
+
+            nint idx = Tensor.IndexOfMinMagnitude(ts);
+            Assert.Equal(0, idx);
+        }
+
+        [Theory]
+        [MemberData(nameof(NonDenseTensorData))]
+        public static void TensorResizeToNonDenseSourceTests(int[] data, nint[] shape, nint[] strides, int[] expectedLogical)
+        {
+            var src = new ReadOnlyTensorSpan<int>(data, shape, strides);
+            Assert.False(src.IsDense);
+
+            // Resize to a larger dense destination
+            nint srcFlatLen = src.FlattenedLength;
+            int[] dstData = new int[(int)srcFlatLen + 2];
+            var dst = new TensorSpan<int>(dstData, [(nint)dstData.Length], [1]);
+            Assert.True(dst.IsDense);
+
+            Tensor.ResizeTo(src, dst);
+
+            for (int i = 0; i < expectedLogical.Length; i++)
+            {
+                Assert.Equal(expectedLogical[i], dstData[i]);
+            }
+            // Extra positions should be zero-filled
+            for (int i = expectedLogical.Length; i < dstData.Length; i++)
+            {
+                Assert.Equal(0, dstData[i]);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(NonDenseTensorData))]
+        public static void TensorResizeToNonDenseDestinationTests(int[] data, nint[] shape, nint[] strides, int[] expectedLogical)
+        {
+            // Create a dense source with known values
+            var src = new ReadOnlyTensorSpan<int>(expectedLogical, [(nint)expectedLogical.Length], [1]);
+            Assert.True(src.IsDense);
+
+            // Create a non-dense destination
+            int[] dstData = new int[data.Length];
+            var dst = new TensorSpan<int>(dstData, shape, strides);
+            Assert.False(dst.IsDense);
+
+            nint copyLength = Math.Min(src.FlattenedLength, dst.FlattenedLength);
+            Tensor.ResizeTo(src, dst);
+
+            // Verify logical elements were written correctly
+            int logicalIdx = 0;
+            foreach (int val in dst)
+            {
+                if (logicalIdx < expectedLogical.Length)
+                {
+                    Assert.Equal(expectedLogical[logicalIdx], val);
+                }
+                logicalIdx++;
+            }
+        }
+
+        [Fact]
+        public static void TensorResizeNonDenseTests()
+        {
+            // 2x3 tensor, slice to 2x2 (non-dense), then resize
+            Tensor<int> tensor = Tensor.Create([10, 20, 30, 40, 50, 60], [2, 3]);
+            Tensor<int> sliced = tensor.Slice(0..2, 0..2);
+            Assert.False(sliced.IsDense);
+
+            Tensor<int> resized = Tensor.Resize(sliced, [3]);
+            Assert.Equal(3, resized.FlattenedLength);
+            Assert.Equal(10, resized[0]);
+            Assert.Equal(20, resized[1]);
+            Assert.Equal(40, resized[2]);
+
+            // 3x4 tensor, slice to 2x2 (non-dense), then resize larger
+            Tensor<int> tensor2 = Tensor.Create(Enumerable.Range(1, 12).ToArray(), [3, 4]);
+            Tensor<int> sliced2 = tensor2.Slice(0..2, 0..2);
+            Assert.False(sliced2.IsDense);
+
+            Tensor<int> resized2 = Tensor.Resize(sliced2, [6]);
+            Assert.Equal(6, resized2.FlattenedLength);
+            Assert.Equal(1, resized2[0]);
+            Assert.Equal(2, resized2[1]);
+            Assert.Equal(5, resized2[2]);
+            Assert.Equal(6, resized2[3]);
+            Assert.Equal(0, resized2[4]);
+            Assert.Equal(0, resized2[5]);
+        }
+
         [Fact]
         public static void TensorMultiplyTests()
         {
@@ -1614,6 +1991,26 @@ public static void TensorConcatenateTests()
             }
         }
 
+        [Fact]
+        public static void TensorConcatenateNonDenseDestinationTests()
+        {
+            Tensor<int> backing = Tensor.CreateFromShape<int>([2, 3]);
+            TensorSpan<int> destination = backing.AsTensorSpan().Slice([0..2, 1..3]);
+            Assert.False(destination.IsDense);
+
+            Tensor<int> t0 = Tensor.Create([1, 2]);
+            Tensor<int> t1 = Tensor.Create([3, 4]);
+
+            Tensor.ConcatenateOnDimension(-1, [t0, t1], destination);
+
+            Assert.Equal(0, backing[0, 0]);
+            Assert.Equal(1, backing[0, 1]);
+            Assert.Equal(2, backing[0, 2]);
+            Assert.Equal(0, backing[1, 0]);
+            Assert.Equal(3, backing[1, 1]);
+            Assert.Equal(4, backing[1, 2]);
+        }
+
         [Fact]
         public static void TensorTransposeTests()
         {
