Initial C# 7.3 upgrade for T : struct constraints

Author: Sergio0694

NeuralNetwork.NET/Extensions/ArrayExtensions.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
 
@@ -19,10 +18,9 @@ internal static class ArrayExtensions
         /// <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
+        public static unsafe T[] Flatten<T>([NotNull] this T[,] m) where T : unmanaged
         {
-            fixed (void* p = &Unsafe.As<T, byte>(ref m[0, 0]))
-                return new Span<T>(p, m.Length * Unsafe.SizeOf<T>()).ToArray();
+            fixed (T* p = m) return new Span<T>(p, m.Length).ToArray();
         }
 
         /// <summary>
@@ -32,17 +30,24 @@ public static unsafe T[] Flatten<T>([NotNull] this T[,] m) where T : struct
         /// <param name="lines">The lines to merge</param>
         [Pure]
         [CollectionAccess(CollectionAccessType.Read)]
-        public static (T[,], T[,]) MergeLines<T>(this IEnumerable<(T[], T[])> lines) where T : struct
+        public static unsafe (T[,], T[,]) MergeLines<T>(this IEnumerable<(T[], T[])> lines) where T : unmanaged
         {
             (T[] X, T[] Y)[] set = lines.ToArray();
             T[,] 
                 x = new T[set.Length, set[0].X.Length],
                 y = new T[set.Length, set[0].Y.Length];
-            Parallel.For(0, set.Length, i =>
+            int
+                wx = x.GetLength(1),
+                wy = y.GetLength(1);
+            fixed (T* px0 = x, py0 = y)
             {
-                set[i].X.AsSpan().CopyTo(x.Slice(i));
-                set[i].Y.AsSpan().CopyTo(y.Slice(i));
-            }).AssertCompleted();
+                T* px = px0, py = py0;
+                Parallel.For(0, set.Length, i =>
+                {
+                    set[i].X.AsSpan().CopyTo(new Span<T>(px + i * wx, wx));
+                    set[i].Y.AsSpan().CopyTo(new Span<T>(py + i * wy, wy));
+                }).AssertCompleted();
+            }
             return (x, y);
         }
     }

NeuralNetwork.NET/Extensions/SpanExtensions.cs

@@ -17,29 +17,27 @@ public static class SpanExtensions
         /// </summary>
         /// <param name="span">The <see cref="Span{T}"/> to fill up</param>
         /// <param name="provider">The values provider to use</param>
-        public static unsafe void Fill<T>(this Span<T> span, [NotNull] Func<T> provider) where T : struct
+        public static unsafe void Fill<T>(this Span<T> span, [NotNull] Func<T> provider) where T : unmanaged
         {
             // Fill in parallel
             int
                 cores = Environment.ProcessorCount,
                 batch = span.Length / cores,
-                mod = span.Length % cores,
-                size = Unsafe.SizeOf<T>();
-            ref T r0 = ref span.DangerousGetPinnableReference();
-            fixed (byte* p0 = &Unsafe.As<T, byte>(ref r0))
+                mod = span.Length % cores;
+            fixed (T* p0 = &span.DangerousGetPinnableReference())
             {
-                byte* pc = p0;
+                T* pc = p0;
                 Parallel.For(0, cores, i =>
                 {
-                    byte* p = pc + i * batch * size;
-                    for (int j = 0; j < batch; j++, p += size)
+                    T* p = pc + i * batch;
+                    for (int j = 0; j < batch; j++, p++)
                         Unsafe.Write(p, provider());
                 }).AssertCompleted();
 
                 // Remaining values
                 if (mod < 1) return;
                 for (int i = span.Length - mod; i < span.Length; i++)
-                    Unsafe.Write(pc + i * size, provider());
+                    Unsafe.Write(pc + i, provider());
             }
         }
 
@@ -51,12 +49,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 unsafe 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 : unmanaged
         {
             if (h * w != span.Length) throw new ArgumentException("The input dimensions don't match the source vector size");
             T[,] m = new T[h, w];
-            fixed (void* p = &Unsafe.As<T, byte>(ref m[0, 0]))
-                span.CopyTo(new Span<T>(p, m.Length * Unsafe.SizeOf<T>()));
+            fixed (void* p = m)
+                span.CopyTo(new Span<T>(p, m.Length));
             return m;
         }
 
@@ -66,16 +64,15 @@ public static unsafe void Fill<T>(this Span<T> span, [NotNull] Func<T> provider)
         /// <typeparam name="T">The type of each value in the input <see cref="Span{T}"/></typeparam>
         /// <param name="span">The input <see cref="Span{T}"/> to read</param>
         [Pure]
-        public static unsafe int GetContentHashCode<T>(this Span<T> span) where T : struct
+        public static unsafe int GetContentHashCode<T>(this Span<T> span) where T : unmanaged
         {
-            fixed (byte* p0 = &Unsafe.As<T, byte>(ref span.DangerousGetPinnableReference()))
+            fixed (T* p0 = &span.DangerousGetPinnableReference())
             {
-                int size = Unsafe.SizeOf<T>();
                 int hash = 17;
                 unchecked
                 {
                     for (int i = 0; i < span.Length; i++)
-                        hash = hash * 23 + Unsafe.Read<T>(p0 + size * i).GetHashCode();
+                        hash = hash * 23 + Unsafe.Read<T>(p0 + i).GetHashCode();
                     return hash;
                 }
             }

NeuralNetwork.NET/Extensions/StreamExtensions.cs

@@ -16,7 +16,7 @@ internal static class StreamExtensions
         /// <typeparam name="T">The <see langword="struct"/> type to serialize</typeparam>
         /// <param name="stream">The target <see cref="Stream"/> to use to write the data</param>
         /// <param name="value">The <see langword="struct"/> to write to the <see cref="Stream"/> instance</param>
-        public static unsafe void Write<T>([NotNull] this Stream stream, T value) where T : struct
+        public static unsafe void Write<T>([NotNull] this Stream stream, T value) where T : unmanaged
         {
             byte[] bytes = new byte[Unsafe.SizeOf<T>()];
             fixed (void* p = bytes) Unsafe.Copy(p, ref value);
@@ -30,7 +30,7 @@ public static unsafe void Write<T>([NotNull] this Stream stream, T value) where
         /// <param name="stream">The source <see cref="Stream"/> instance to use to read the data</param>
         /// <param name="value">The resulting <typeparamref name="T"/> value that is read from the <see cref="Stream"/></param>
         [MustUseReturnValue]
-        public static unsafe bool TryRead<T>([NotNull] this Stream stream, out T value) where T : struct
+        public static unsafe bool TryRead<T>([NotNull] this Stream stream, out T value) where T : unmanaged
         {
             byte[] bytes = new byte[Unsafe.SizeOf<T>()];
             value = default;

NeuralNetwork.NET/Helpers/Sha256.cs

@@ -24,11 +24,11 @@ public static class Sha256
         /// <param name="array">The input array to process</param>
         [PublicAPI]
         [Pure, NotNull]
-        public static unsafe byte[] Hash<T>([NotNull] T[] array) where T : struct
+        public static unsafe byte[] Hash<T>([NotNull] T[] array) where T : unmanaged
         {
             int size = Unsafe.SizeOf<T>() * array.Length;
-            fixed (byte* p = &Unsafe.As<T, byte>(ref array[0]))
-            using (UnmanagedMemoryStream stream = new UnmanagedMemoryStream(p, size, size, FileAccess.Read))
+            fixed (T* p = array)
+            using (UnmanagedMemoryStream stream = new UnmanagedMemoryStream((byte*)p, size, size, FileAccess.Read))
             using (SHA256 provider = SHA256.Create())
             {
                 return provider.ComputeHash(stream);
@@ -42,7 +42,7 @@ public static unsafe byte[] Hash<T>([NotNull] T[] array) where T : struct
         /// <param name="arrays">The arrays to process</param>
         [PublicAPI]
         [Pure, NotNull]
-        public static unsafe byte[] Hash<T>([NotNull, ItemNotNull] params T[][] arrays) where T : struct
+        public static unsafe byte[] Hash<T>([NotNull, ItemNotNull] params T[][] arrays) where T : unmanaged
         {
             // Compute the hashes in parallel
             if (arrays.Length == 0) return new byte[0];

NeuralNetwork.NET/SupervisedLearning/Data/Pin{T}.cs

@@ -7,7 +7,7 @@ namespace NeuralNetworkNET.SupervisedLearning.Data
     /// It can be used to replace <see cref="System.Span{T}"/> to quickly pass pointers around in non stack-only methods.
     /// </summary>
     /// <typeparam name="T">The type of the target referenced by the exposed pointer</typeparam>
-    internal readonly unsafe struct Pin<T> where T : struct
+    internal readonly unsafe struct Pin<T> where T : unmanaged
     {
         /// <summary>
         /// The pinned pointer