redesign matrix design

StgSharp.Common/Mathematics/Linear/Matrix.Create.cs

@@ -1,6 +1,6 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
-// file="MatrixEnum"
+// file="Matrix.Create"
 // Project: StgSharp
 // AuthorGroup: Nitload
 // Copyright (c) Nitload. All rights reserved.
@@ -25,6 +25,7 @@
 //     
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
+using StgSharp.HighPerformance.Memory;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -33,11 +34,24 @@ using System.Threading.Tasks;
 
 namespace StgSharp.Mathematics.Numeric
 {
-    public enum MatrixAllocation
+    public unsafe partial class Matrix<T>
     {
 
-        HLSF,
+        public static Matrix<T> Create(
-        GC,
+                                int columnLength,
+                                int rowLength,
+                                HybridLayerSegregatedFitAllocator allocator)
+        {
+            Matrix<T> matrix = new Matrix<T>();
+            int tSize = sizeof(T);
+            int totalSize = columnLength * rowLength * tSize;
+            HybridLayerSegregatedFitAllocationHandle handle = allocator.Alloc((uint)totalSize);
+            MatrixStorageHLSF<T> storage = new MatrixStorageHLSF<T>(handle);
+            storage._handle = handle;
+            matrix._buffer = storage;
+            matrix._enumeration = new MatrixMetadata(columnLength, rowLength);
+            return matrix;
+        }
 
     }
 }

StgSharp.Common/Mathematics/Linear/Matrix.cs

@@ -25,59 +25,74 @@
 //     
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
+using StgSharp.HighPerformance;
+using StgSharp.Mathematics.Numeric;
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Numerics;
 using System.Runtime.CompilerServices;
-using System.Text;
+using System.Runtime.InteropServices;
-using System.Threading.Tasks;
 
-using hlsfAllocator = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator;
+// using hlsfHandle = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle;
 
 namespace StgSharp.Mathematics.Numeric
 {
-    public static class Matrix
+    public unsafe partial class Matrix<T> where T : unmanaged, INumber<T>
     {
 
-        public static hlsfAllocator? DefaultAllocator
+        private protected static readonly int t_count = 16 / sizeof(T);
+
+        private protected static readonly int t_size = sizeof(T);
+        private MatrixMetadata _enumeration;
+
+        private MatrixStorage<T> _buffer;
+
+        private protected Matrix() { }
+
+        public ref T this[int column, int row]
         {
-            get
+            get => throw new NotImplementedException();
-            {
+        }
-                ArgumentNullException.ThrowIfNull(field, nameof(DefaultAllocator));
+
-                return null;
+        public unsafe Matrix<T> this[
+                                ReadOnlySpan<MatrixIndex> column,
+                                ReadOnlySpan<MatrixIndex> row]
+        {
+            get { throw new NotImplementedException(); }
+            set { throw new NotImplementedException(); }
+        }
+
+        /// <summary>
+        ///   Length of the matrix in columns.
+        /// </summary>
+        public int ColumnLength { get; init; }
+
+        /// <summary>
+        ///   Length of the matrix in rows.
+        /// </summary>
+        public int RowLength { get; init; }
+
+        public MatrixLayout Layout { get; init; }
+
+        internal MatrixKernel<T>* Buffer { get; }
+
+        protected internal int KernelColumnLength { get; init; }
+
+        protected internal int KernelRowLength { get; init; }
+
+        public ref MatrixKernel<T> GetMatrixKernel(int column, int row)
+        {
+            if (_enumeration.GetCurrentKernelIndex) { } else { }
+        }
+
+        private protected void AssertIndex(int column, int row)
+        {
+            if (column < 0 || column >= ColumnLength) {
+                throw new ArgumentOutOfRangeException(nameof(column));
             }
-            set;
-        } = null;
 
-        public static MatrixAllocation DefaultAllocation { get; set; } = MatrixAllocation.GC;
+            if (row < 0 || row >= RowLength) {
-
+                throw new ArgumentOutOfRangeException(nameof(row));
-        public static Matrix<T> FromDefault<T>(int columnLength, int rowLength)
+            }
-            where T : unmanaged, INumber<T>
-        {
-            return DefaultAllocation switch
-            {
-                MatrixAllocation.GC => FromGC<T>(columnLength, rowLength),
-                MatrixAllocation.HLSF => FromHlsf<T>(columnLength, rowLength, DefaultAllocator!),
-                _ => throw new NotSupportedException("This allocation is not supported."),
-            };
-        }
-
-        public static Matrix<T> FromGC<T>(int columnLength, int rowLength)
-            where T : unmanaged, INumber<T>
-        {
-            return new GCMatrix<T>(columnLength, rowLength);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Matrix<T> FromHlsf<T>(
-                                int columnLength,
-                                int rowLength,
-                                hlsfAllocator allocator)
-            where T : unmanaged, INumber<T>
-        {
-            ArgumentNullException.ThrowIfNull(allocator, nameof(allocator));
-            return new HlsfMatrix<T>(columnLength, rowLength, allocator);
         }
 
     }

StgSharp.Common/Mathematics/Linear/MatrixMetadata.cs

@@ -0,0 +1,114 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="MatrixMetadata"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.HighPerformance;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Mathematics.Numeric
+{
+    public enum MatrixLayout
+    {
+
+        DenseSquare,
+        UpperTriangle,
+        LowerTriangle,
+
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe struct MatrixKernelEnumeration
+    {
+
+        public readonly delegate* unmanaged[Cdecl]
+            <int, int, MatrixKernelEnumerator*, long> GetIndexOffset;
+
+        public readonly delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, bool> IsInBuffer;
+
+        [Obsolete("Do not use constructor, use static method instead", true)]
+        public MatrixKernelEnumeration() { }
+
+        public MatrixKernelEnumeration(
+               delegate* unmanaged[Cdecl]
+           <int, int, MatrixKernelEnumerator*, long> getOffset,
+               delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, bool> inBuffer)
+        {
+            GetIndexOffset = getOffset;
+            IsInBuffer = inBuffer;
+        }
+
+        private static delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, bool> IsInBufferDenseSquarePtr { get; } = (delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, bool>)&IsInBufferDenseSquare;
+
+        public static MatrixKernelEnumeration Create(MatrixLayout layout)
+        {
+            return layout switch
+            {
+                MatrixLayout.DenseSquare => new MatrixKernelEnumeration(null, IsInBufferDenseSquarePtr),
+
+                MatrixLayout.UpperTriangle => throw new NotImplementedException(),
+            };
+        }
+
+        private static bool IsInBufferDenseSquare(
+                            int col,
+                            int row,
+                            MatrixKernelEnumerator* enumerator)
+        {
+            return true;
+        }
+
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    public struct MatrixSize
+    {
+
+        [FieldOffset(0)] public readonly int ElementColumnLength;
+        [FieldOffset(4)] public readonly int ElementRowLength;
+
+        [FieldOffset(8)] public readonly int KernelColumnLength;
+        [FieldOffset(12)] public readonly int KernelRowLength;
+
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    public struct MatrixKernelEnumerator
+    {
+
+        [FieldOffset(0)] public int CurrentColumn;
+        [FieldOffset(4)] public int CurrentRow;
+
+        [FieldOffset(8)] public  readonly int KernelColumnLength;
+        [FieldOffset(12)] public readonly int KernelRowLength;
+
+    }
+}

StgSharp.Common/Mathematics/Linear/MatrixStorage.cs

@@ -0,0 +1,65 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="MatrixStorage"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.HighPerformance.Memory;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+
+using HLSFAllocator = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator;
+using HLSFHandle = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle;
+
+namespace StgSharp.Mathematics.Numeric
+{
+    public abstract class MatrixStorage<T> : IDisposable where T : unmanaged, INumber<T>
+    {
+
+        protected internal abstract unsafe T* BufferPointer { get; }
+
+        public abstract void Dispose();
+
+    }
+
+    internal class MatrixStorageHLSF<T>(HLSFAllocator allocator, HLSFHandle handle) : MatrixStorage<T>
+        where T : unmanaged, INumber<T>
+    {
+
+        internal HLSFAllocator _allocator = allocator;
+        internal HLSFHandle _handle = handle;
+
+        protected internal override unsafe T* BufferPointer => (T*)_handle.Pointer;
+
+        public override void Dispose()
+        {
+            allocator.Free(_handle);
+        }
+
+    }
+}

StgSharp.Common/Mathematics/Linear/Matrix_T.GC.cs

@@ -1,124 +0,0 @@
-//-----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-// file="Matrix_T.GC"
-// Project: StgSharp
-// AuthorGroup: Nitload
-// Copyright (c) Nitload. All rights reserved.
-//     
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-//     
-// -----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-using StgSharp.HighPerformance;
-using StgSharp.Mathematics;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StgSharp.Mathematics.Numeric
-{
-    internal unsafe partial class GCMatrix<T> : Matrix<T> where T : unmanaged, INumber<T>
-    {
-
-        private readonly MatrixKernel<T>* _buffer;
-
-        public GCMatrix(int column, int row)
-        {
-            KernelColumnLength = (column + 3) / 4;
-            KernelRowLength = (row + 3) / t_count;
-            ColumnLength = column;
-            RowLength = row;
-            _buffer = (MatrixKernel<T>*)NativeMemory.AlignedAlloc((nuint)(column * row * sizeof(T)), (nuint)World.DefaultSIMDAlignment);
-        }
-
-        public override ref T this[int column, int row]
-        {
-            get
-            {
-                AssertIndex(column, row);
-                int kernelColumn = column / 4, c = column % 4;
-                int kernelRow = row / t_count, r = row % t_count;
-                ref MatrixKernel<T> kernel = ref _buffer[kernelColumn + KernelColumnLength * kernelRow];
-                return ref kernel[c, r];
-            }
-        }
-
-        public override Matrix<T> this[ReadOnlySpan<MatrixIndex> column, ReadOnlySpan<MatrixIndex> row]
-        {
-            get => throw new NotImplementedException();
-            set => throw new NotImplementedException();
-        }
-
-        internal override unsafe MatrixKernel<T>* Buffer
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => _buffer;
-        }
-
-        public override unsafe ref MatrixKernel<T> GetMatrixKernel(int column, int row)
-        {
-            AssertIndex(column, row);
-            int kernelColumn = column / 4;
-            int kernelRow = row / t_count;
-            return ref _buffer[kernelColumn + (KernelColumnLength * kernelRow)];
-        }
-
-        public override ref T UnsafeIndex(int column, int row)
-        {
-            int kernelColumn = column / 4, c = column % 4;
-            int kernelRow = row / t_count, r = row % t_count;
-            ref MatrixKernel<T> kernel = ref _buffer[kernelColumn + (KernelColumnLength * kernelRow)];
-            return ref kernel[c, r];
-        }
-
-        ~GCMatrix()
-        {
-            NativeMemory.AlignedFree(_buffer);
-        }
-
-        #region enumeration
-
-        public override unsafe MatrixSegmentEnumeration<T> ColumnEnumeration
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => new MatrixSegmentEnumeration<T>(_buffer, KernelColumnLength, KernelColumnLength * KernelRowLength, 1,
-                                                   KernelColumnLength);
-        }
-
-        public override unsafe MatrixSegmentEnumeration<T> GetRowEnumeration()
-        {
-            return new MatrixSegmentEnumeration<T>(_buffer, 1, KernelColumnLength, KernelColumnLength, KernelRowLength);
-        }
-
-        public override unsafe MatrixSegmentEnumeration<T> SequentialEnumeration
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => new MatrixSegmentEnumeration<T>(_buffer, KernelRowLength * KernelColumnLength,
-                                                   KernelColumnLength * KernelRowLength, 1,
-                                                   KernelRowLength * KernelColumnLength);
-        }
-
-        #endregion
-    }
-}

StgSharp.Common/Mathematics/Linear/Matrix_T.HLSF.cs

@@ -1,137 +0,0 @@
-//-----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-// file="Matrix_T.HLSF"
-// Project: StgSharp
-// AuthorGroup: Nitload
-// Copyright (c) Nitload. All rights reserved.
-//     
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-//     
-// -----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-using StgSharp.HighPerformance;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
-
-using hlsfAllocator = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocator;
-using hlsfHandle = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle;
-
-namespace StgSharp.Mathematics.Numeric
-{
-    internal unsafe partial class HlsfMatrix<T> : Matrix<T> where T : unmanaged, INumber<T>
-    {
-
-        private readonly MatrixKernel<T>* k_buffer;
-        private readonly hlsfAllocator allocator;
-        private readonly hlsfHandle handle;
-
-        internal HlsfMatrix(int column, int row, hlsfAllocator allocator)
-        {
-            KernelColumnLength = (column + 3) / 4;
-            KernelRowLength = (row + 3) / t_count;
-            ColumnLength = column;
-            RowLength = row;
-            long size = (long)KernelColumnLength * (long)KernelRowLength * (long)sizeof(MatrixKernel<T>);
-            this.handle = allocator.Alloc((uint)(size));
-            if (handle.AllocSize < size) {
-                throw new InsufficientMemoryException();
-            }
-            k_buffer = (MatrixKernel<T>*)handle.Pointer;
-        }
-
-        public override ref T this[int column, int row]
-        {
-            get
-            {
-                AssertIndex(column, row);
-                int kernelColumn = column / 4, c = column % 4;
-                int kernelRow = row / t_count, r = row % t_count;
-                ref MatrixKernel<T> kernel = ref k_buffer[(kernelColumn * kernelColumn) + kernelRow];
-                return ref kernel[c, r];
-            }
-        }
-
-        public override Matrix<T> this[
-                                  ReadOnlySpan<MatrixIndex> column,
-                                  ReadOnlySpan<MatrixIndex> row]
-        {
-            get => throw new NotImplementedException();
-            set => throw new NotImplementedException();
-        }
-
-        internal override unsafe MatrixKernel<T>* Buffer
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => k_buffer;
-        }
-
-        public override unsafe ref MatrixKernel<T> GetMatrixKernel(int column, int row)
-        {
-            AssertIndex(column, row);
-            int kernelColumn = column / 4, c = column % 4;
-            int kernelRow = row / t_count, r = row % t_count;
-            return ref k_buffer[(kernelColumn * kernelColumn) + kernelRow];
-        }
-
-        public override ref T UnsafeIndex(int column, int row)
-        {
-            int kernelColumn = column / 4, c = column % 4;
-            int kernelRow = row / t_count, r = row % t_count;
-            ref MatrixKernel<T> kernel = ref k_buffer[(kernelColumn * kernelColumn) + kernelRow];
-            return ref kernel[c, r];
-        }
-
-        ~HlsfMatrix()
-        {
-            allocator.Free(handle);
-        }
-
-        #region enumeration
-
-        public override unsafe MatrixSegmentEnumeration<T> ColumnEnumeration
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => new MatrixSegmentEnumeration<T>(k_buffer, KernelColumnLength,
-                                                   KernelColumnLength * KernelRowLength, 1,
-                                                   KernelColumnLength);
-        }
-
-        public override unsafe MatrixSegmentEnumeration<T> GetRowEnumeration()
-        {
-            return new MatrixSegmentEnumeration<T>(k_buffer, 1, KernelColumnLength,
-                                                   KernelColumnLength, KernelRowLength);
-        }
-
-        public override unsafe MatrixSegmentEnumeration<T> SequentialEnumeration
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-
-            get => new MatrixSegmentEnumeration<T>(k_buffer, KernelRowLength * KernelColumnLength,
-                                                   KernelColumnLength * KernelRowLength, 1,
-                                                   KernelRowLength * KernelColumnLength);
-        }
-
-        #endregion
-    }
-}

StgSharp.Common/Mathematics/Linear/Matrix_T.cs

@@ -1,218 +0,0 @@
-//-----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-// file="Matrix_T"
-// Project: StgSharp
-// AuthorGroup: Nitload
-// Copyright (c) Nitload. All rights reserved.
-//     
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-//     
-// -----------------------------------------------------------------------
-// -----------------------------------------------------------------------
-using StgSharp.HighPerformance;
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// using hlsfHandle = global::StgSharp.HighPerformance.Memory.HybridLayerSegregatedFitAllocationHandle;
-
-namespace StgSharp.Mathematics.Numeric
-{
-    public abstract unsafe partial class Matrix<T> where T : unmanaged, INumber<T>
-    {
-
-        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 unsafe Matrix<T> this[ReadOnlySpan<MatrixIndex> column, ReadOnlySpan<MatrixIndex> row]
-        {
-            get;
-            set;
-        }
-
-        /// <summary>
-        ///   Length of the matrix in columns.
-        /// </summary>
-        public int ColumnLength { get; init; }
-
-        /// <summary>
-        ///   Length of the matrix in rows.
-        /// </summary>
-        public int RowLength { get; init; }
-
-        public abstract MatrixSegmentEnumeration<T> ColumnEnumeration { get; }
-
-        public abstract MatrixSegmentEnumeration<T> SequentialEnumeration { get; }
-
-        internal abstract MatrixKernel<T>* Buffer { get; }
-
-        protected internal int KernelColumnLength { get; init; }
-
-        protected internal int KernelRowLength { get; init; }
-
-        public abstract ref MatrixKernel<T> GetMatrixKernel(int column, int row);
-
-        public abstract MatrixSegmentEnumeration<T> GetRowEnumeration();
-
-        [Obsolete("This method does not contain boarder check, so be careful on size or use indexer instead.", false)]
-        public abstract ref T UnsafeIndex(int column, int row);
-
-        private protected void AssertIndex(int column, int row)
-        {
-            if (column < 0 || column >= ColumnLength) {
-                throw new ArgumentOutOfRangeException(nameof(column));
-            }
-
-            if (row < 0 || row >= RowLength) {
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-    }
-
-    public readonly unsafe ref struct MatrixSegmentEnumeration<T>(
-                                      MatrixKernel<T>* source,
-                                      int primStride,
-                                      int primSize,
-                                      int secondaryStride,
-                                      int secondarySize,
-                                      int primOffset = 0,
-                                      int secondaryOffset = 0)
-        where T : unmanaged, INumber<T>
-    {
-
-        private readonly MatrixKernel<T>* _source = source;
-        internal readonly int PrimOffset = primOffset;
-
-        internal readonly int PrimSize = primSize;
-        internal readonly int PrimStride = primStride;
-        internal readonly int SecondaryOffset = secondaryOffset;
-        internal readonly int SecondarySize = secondarySize;
-        internal readonly int SecondaryStride = secondaryStride;
-
-        internal readonly MatrixKernel<T>* Source
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => _source;
-        }
-
-        public Enumerator GetEnumerator()
-        {
-            return new Enumerator(in this);
-        }
-
-        public ref struct Enumerator(in MatrixSegmentEnumeration<T> enumeration)
-        {
-
-            private readonly MatrixKernel<T>* _source = enumeration._source;
-            private int _indexCount = -1;
-            private readonly int _stride = enumeration.PrimStride;
-            private readonly long _bound = (long)enumeration.PrimSize * enumeration.PrimStride;
-            private long _index = (long)enumeration.PrimOffset * enumeration.PrimStride;
-
-            private readonly MatrixSegmentEnumeration<T> _enumeration;
-
-            public readonly MatrixSegment<T> Current
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get => new(_source + _index, _enumeration.SecondarySize, _enumeration.SecondaryStride,
-                           _enumeration.PrimOffset);
-            }
-
-            public bool MoveNext()
-            {
-                _indexCount++;
-                _index += _stride;
-                if (_index >= _bound) {
-                    _index = 0;
-                }
-                return _indexCount >= _enumeration.PrimSize;
-            }
-
-        }
-
-    }
-
-    public readonly unsafe ref struct MatrixSegment<T>(MatrixKernel<T>* source, int size, int stride, int offset)
-        where T : unmanaged, INumber<T>
-    {
-
-        private readonly MatrixKernel<T>* _source = source;
-        private readonly int _offset = offset;
-        private readonly int _secondarySize = size;
-        private readonly int _size = size;
-        private readonly int _stride = stride;
-
-        public ref MatrixKernel<T> this[int index]
-        {
-            get
-            {
-                if (index < 0 || index >= _size) {
-                    throw new ArgumentOutOfRangeException(nameof(index));
-                }
-                return ref _source[index * _stride];
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Enumerator GetEnumerator()
-        {
-            return new Enumerator(in this);
-        }
-
-        public ref struct Enumerator(in MatrixSegment<T> segment)
-        {
-
-            private readonly int _end = segment._size;
-
-            private int _indexCount = -1;
-            private readonly long _bound = (long)segment._size * segment._stride;
-            private long _index = (long)segment._offset * segment._stride;
-            private readonly MatrixSegment<T> _segment = segment;
-
-            public readonly MatrixKernel<T>* Current
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get => _segment._source + _index;
-            }
-
-            public bool MoveNext()
-            {
-                _index += _segment._stride;
-                _indexCount++;
-                if (_index >= _bound) {
-                    _index = 0;
-                }
-
-                return _indexCount < _end;
-            }
-
-        }
-
-    }
-}

StgSharp.Mathematics/Numeric/MatrixCompute.Factorize.cs

@@ -38,7 +38,7 @@ namespace StgSharp.Mathematics.Numeric
 
         public static void FactorizePLU(
                            Matrix<float> matrix,
-                           Matrix<float> p,
+                           Span<float> p,
                            Matrix<float> lower,
                            Matrix<float> upper)
         {

StgSharp.Native/sn-src/k_pivot.c

@@ -2,7 +2,7 @@
 
 // Hybrid implementation: SIMD for Abs, Scalar for Max
 // Assumes Column-Major layout for both MAT_KERNEL content and Kernel sequence
-static void povit_float_simd_abs(MAT_KERNEL(float) const *source, size_t col_begin,
+static void povit_float(MAT_KERNEL(float) const *source, size_t col_begin,
                                  size_t col_length, size_t *restrict ans)
 {
         float max_v[4] = { -1.0f, -1.0f, -1.0f, -1.0f };
@@ -62,18 +62,3 @@ static void povit_float_simd_abs(MAT_KERNEL(float) const *source, size_t col_beg
                 }
         }
 }
-
-DECLARE_MAT_POVIT_PROC(float, sse)
-{
-        povit_float_simd_abs(source, col_begin, col_length, ans);
-}
-
-DECLARE_MAT_POVIT_PROC(float, avx)
-{
-        povit_float_simd_abs(source, col_begin, col_length, ans);
-}
-
-DECLARE_MAT_POVIT_PROC(float, 512)
-{
-        povit_float_simd_abs(source, col_begin, col_length, ans);
-}