Removed AsSpan<T>(this T[,]) extension method

Author: Sergio0694

NeuralNetwork.NET/APIs/Structs/Tensor.cs

@@ -281,7 +281,8 @@ public unsafe float[] ToArray(bool keepAlive = true)
         {
             if (Ptr == IntPtr.Zero) return new float[0, 0];
             float[,] result = new float[Entities, Length];
-            new Span<float>(this, Size).CopyTo(result.AsSpan());
+            fixed (float* p = result)
+                new Span<float>(this, Size).CopyTo(new Span<float>(p, Size));
             if (!keepAlive) Free();
             return result;
         }

NeuralNetwork.NET/Extensions/ArrayExtensions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
 
@@ -11,6 +12,19 @@ namespace NeuralNetworkNET.Extensions
     /// </summary>
     internal static class ArrayExtensions
     {
+        /// <summary>
+        /// Flattens a 2D array to a 1D array
+        /// </summary>
+        /// <typeparam name="T">The type of each element in the input matrix</typeparam>
+        /// <param name="m">The input 2D array to flatten</param>
+        [Pure]
+        [CollectionAccess(CollectionAccessType.Read)]
+        public static unsafe T[] Flatten<T>([NotNull] this T[,] m) where T : struct
+        {
+            fixed (void* p = &Unsafe.As<T, byte>(ref m[0, 0]))
+                return new Span<T>(p, m.Length * Unsafe.SizeOf<T>()).ToArray();
+        }
+
         /// <summary>
         /// Merges the line pairs in the input collection into two 2D arrays
         /// </summary>

NeuralNetwork.NET/Extensions/DebugExtensions.cs

@@ -55,13 +55,14 @@ public static bool ContentEquals(in this Tensor m, in Tensor o, float absolute =
         /// <param name="o">The second matrix to test</param>
         /// <param name="absolute">The relative comparison threshold</param>
         /// <param name="relative">The relative comparison threshold</param>
-        public static bool ContentEquals([CanBeNull] this float[,] m, [CanBeNull] float[,] o, float absolute = 1e-6f, float relative = 1e-6f)
+        public static unsafe bool ContentEquals([CanBeNull] this float[,] m, [CanBeNull] float[,] o, float absolute = 1e-6f, float relative = 1e-6f)
         {
             if (m == null && o == null) return true;
             if (m == null || o == null) return false;
             if (m.GetLength(0) != o.GetLength(0) ||
                 m.GetLength(1) != o.GetLength(1)) return false;
-            return m.AsSpan().ContentEquals(o.AsSpan(), absolute, relative);
+            fixed (float* pm = m, po = o)
+                return new Span<float>(pm, m.Length).ContentEquals(new Span<float>(po, o.Length), absolute, relative);
         }
 
         /// <summary>

NeuralNetwork.NET/Extensions/SpanExtensions.cs

@@ -51,11 +51,12 @@ public static unsafe void Fill<T>(this Span<T> span, [NotNull] Func<T> provider)
         /// <param name="w">The number of matrix columns</param>
         [Pure, NotNull]
         [CollectionAccess(CollectionAccessType.Read)]
-        public static T[,] AsMatrix<T>(this Span<T> span, int h, int w) where T : struct
+        public static unsafe T[,] AsMatrix<T>(this Span<T> span, int h, int w) where T : struct
         {
             if (h * w != span.Length) throw new ArgumentException("The input dimensions don't match the source vector size");
             T[,] m = new T[h, w];
-            span.CopyTo(m.AsSpan());
+            fixed (void* p = &Unsafe.As<T, byte>(ref m[0, 0]))
+                span.CopyTo(new Span<T>(p, m.Length * Unsafe.SizeOf<T>()));
             return m;
         }
 
@@ -94,15 +95,6 @@ public static T[] Copy<T>(this Span<T> span) where T : struct
             return result;
         }
 
-        /// <summary>
-        /// Returns a new <see cref="Span{T}"/> instance from the input matrix
-        /// </summary>
-        /// <typeparam name="T">The type of the input matrix</typeparam>
-        /// <param name="m">The input matrix</param>
-        [Pure]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Span<T> AsSpan<T>([NotNull] this T[,] m) where T : struct => Span<T>.DangerousCreate(m, ref m[0, 0], m.Length);
-
         /// <summary>
         /// Extracts a single row from a given matrix
         /// </summary>

NeuralNetwork.NET/Networks/Implementations/ComputationGraphNetwork.cs

@@ -422,8 +422,8 @@ private static unsafe bool TryExecuteMergeForward([NotNull] TensorMap<IComputati
         public override IReadOnlyList<(float[] Z, float[] A)> ExtractDeepFeatures(float[] x)
         {
             return (from pair in ExtractDeepFeatures(x.AsSpan().AsMatrix(1, x.Length))
-                    let z = pair.Z?.AsSpan().ToArray()
-                    let a = pair.A.AsSpan().ToArray()
+                    let z = pair.Z?.Flatten()
+                    let a = pair.A.Flatten()
                     select (z, a)).ToArray();
         }