Merge from branch giga

StgSharp.Common/Mathematics/Linear/Matrix.cs

@@ -29,47 +29,191 @@
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 using StgSharp.HighPerformance;
-using StgSharp.HighPerformance.Memory;
-
 using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Linq;
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using System.Text;
-using System.Threading.Tasks;
-
-using hlsfHandle = StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle;
+using hlsfAllocator = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator;
+using hlsfHandle = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle;
 
 namespace StgSharp.Mathematics
 {
     public abstract unsafe partial class Matrix<T> where T: unmanaged, INumber<T>
     {
 
-        public abstract ref float this[int column, int row]
+        private protected readonly int t_count = 16 / sizeof(T);
+
+        private protected readonly int t_size = sizeof(T);
+
+        private protected Matrix() { }
+
+        public abstract ref T this[int column, int row]
         {
             get;
         }
 
-        public abstract MatrixKernel* GetMatrixKernel(int column, int row);
+        public abstract unsafe Matrix<T> this[ReadOnlySpan<MatrixIndex> column, ReadOnlySpan<MatrixIndex> row]
+        {
+            get;
+            set;
+        }
+
+        public static hlsfAllocator? DefaultAllocator
+        {
+            get
+            {
+                ArgumentNullException.ThrowIfNull(field, nameof(DefaultAllocator));
+                return null;
+            }
+            set;
+        } = null;
+
+        public int ColumnLength { get; init; }
+
+        public int RowLength { get; init; }
+
+        public static MatrixAllocation DefaultAllocation { get; set; } = MatrixAllocation.GC;
+
+        protected int KernelColumnLength { get; init; }
+
+        protected int KernelRowLength { get; init; }
+
+        public static Matrix<T> FromDefault(int columnLength, int rowLength)
+        {
+            return DefaultAllocation switch
+            {
+                MatrixAllocation.GC => FromGC(columnLength, rowLength),
+                MatrixAllocation.HLSF => FromHlsf(columnLength, rowLength, DefaultAllocator!),
+                _ => throw new NotSupportedException("This allocation is not supported."),
+            };
+        }
+
+        public static Matrix<T> FromGC(int columnLength, int rowLength)
+        {
+            return new GCMatrix<T>(columnLength, rowLength);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Matrix<T> FromHlsf(int columnLength, int rowLength, hlsfAllocator allocator)
+        {
+            return new HlsfMatrix<T>(columnLength, rowLength, allocator);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public abstract MatrixSegmentEnumeration GetColumnEnumeration();
+
+        public abstract ref MatrixKernel GetMatrixKernel(int column, int row);
+
+        public abstract MatrixSegmentEnumeration GetRowEnumeration();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public abstract MatrixSegmentEnumeration GetSequentialEnumeration();
 
         [Obsolete("This method does not contain boarder check, so be careful on size or use indexer instead.", false)]
-        public abstract T* UnsafeIndex(int column, int row);
+        public abstract ref T UnsafeIndex(int column, int row);
 
-    }
-
-    private unsafe class HlsfMatrix<T> : Matrix<T> where T : unmanaged, INumber<T>
-    {
-        public override ref float this[int column, int row] => throw new NotImplementedException();
-
-        public override unsafe MatrixKernel* GetMatrixKernel(int column, int row)
+        private protected void AssertIndex(int column, int row)
         {
-            throw new NotImplementedException();
+            if (column < 0 || column >= ColumnLength) {
+                throw new ArgumentOutOfRangeException(nameof(column));
+            }
+
+            if (row < 0 || row >= RowLength) {
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
         }
 
-        public override unsafe T* UnsafeIndex(int column, int row)
+        public readonly unsafe ref struct MatrixSegmentEnumeration(
+                                          MatrixKernel* source,
+                                          int stride,
+                                          int size,
+                                          int secondaryStride,
+                                          int secondarySize)
         {
-            throw new NotImplementedException();
+
+            private readonly MatrixKernel* _source = source;
+            private readonly int _secondarySize = secondarySize;
+            private readonly int _secondaryStride = secondaryStride;
+
+            private readonly int _size = size;
+            private readonly int _stride = stride;
+
+            public Enumerator GetEnumerator()
+            {
+                return new Enumerator(in this);
+            }
+
+            public ref struct Enumerator(in MatrixSegmentEnumeration enumeration)
+            {
+
+                private MatrixKernel* _current = enumeration._source - enumeration._stride;
+                private readonly MatrixKernel* _end = enumeration._source + enumeration._size;
+                private readonly int _secondarySize = enumeration._secondarySize;
+                private readonly int _secondaryStride = enumeration._secondaryStride;
+                private readonly int _stride = enumeration._stride;
+
+                public readonly Segment Current
+                {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+                    get => new(_current, _secondarySize, _secondaryStride);
+                }
+
+                public bool MoveNext()
+                {
+                    _current += _stride;
+                    return _current < _end;
+                }
+
+            }
+
         }
+
+        public readonly unsafe ref struct Segment(MatrixKernel* source, int size, int stride)
+        {
+
+            private readonly MatrixKernel* _source = source;
+            private readonly int _size = size;
+            private readonly int _stride = stride;
+
+            public ref MatrixKernel this[int index]
+            {
+                get
+                {
+                    if (index < 0 || index >= _size) {
+                        throw new ArgumentOutOfRangeException(nameof(index));
+                    }
+                    return ref _source[index * _stride];
+                }
+            }
+
+            public Enumerator GetEnumerator()
+            {
+                return new Enumerator(_source, _size, _stride);
+            }
+
+            public ref struct Enumerator(MatrixKernel* source, int count, int stride)
+            {
+
+                private readonly MatrixKernel* _end = source + (count * stride);
+                private readonly int _stride = stride;
+
+                public MatrixKernel* Current
+                {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+                    get;
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+                    private set;
+                } = source - stride;
+
+                public bool MoveNext()
+                {
+                    Current += _stride;
+                    return Current < _end;
+                }
+
+            }
+
+        }
+
     }
 }