stgsharp/StgSharp.Common/Mathematics/Linear/MatrixMetadata.cs

//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// 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 MatrixKernelBoarder
    {

        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 MatrixKernelBoarder() { }

        public MatrixKernelBoarder(
               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*, long> GetIndexOffsetDenseSquarePtr { get; } =
            (delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, long>)&GetIndexOffsetDenseSquare;

        private static delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, long> GetIndexOffsetUpperTrianglePtr { get; } =
            (delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, long>)&GetIndexOffsetUpperTriangle;

        private static delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, long> GetIndexOffsetLowerTrianglePtr { get; } =
            (delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, long>)&GetIndexOffsetLowerTriangle;

        private static delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, bool> IsInBufferDenseSquarePtr { get; } =
            (delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, bool>)&IsInBufferDenseSquare;

        private static delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, bool> IsInBufferUpperTrianglePtr { get; } =
            (delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, bool>)&IsInBufferUpperTriangle;

        private static delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, bool> IsInBufferLowerTrianglePtr { get; } =
            (delegate* unmanaged[Cdecl]<int, int, MatrixKernelEnumerator*, bool>)&IsInBufferLowerTriangle;

        public static MatrixKernelBoarder Create(MatrixLayout layout)
        {
            return layout switch
            {
                MatrixLayout.DenseSquare => new MatrixKernelBoarder(GetIndexOffsetDenseSquarePtr, IsInBufferDenseSquarePtr),

                MatrixLayout.UpperTriangle => new MatrixKernelBoarder(GetIndexOffsetUpperTrianglePtr, IsInBufferUpperTrianglePtr),
                MatrixLayout.LowerTriangle => new MatrixKernelBoarder(GetIndexOffsetLowerTrianglePtr, IsInBufferLowerTrianglePtr),
                _ => throw new ArgumentOutOfRangeException(nameof(layout)),
            };
        }

        [UnmanagedCallersOnly(CallConvs =[ typeof(CallConvCdecl) ])]
        private static long GetIndexOffsetDenseSquare(
                            int x_kernel,
                            int y_kernel,
                            MatrixKernelEnumerator* enumerator)
        {
            long x = x_kernel;
            long y = y_kernel;
            long rows = enumerator->KernelRowLength;
            return x * rows + y;
        }

        [UnmanagedCallersOnly(CallConvs =[ typeof(CallConvCdecl) ])]
        private static long GetIndexOffsetLowerTriangle(
                            int x_kernel,
                            int y_kernel,
                            MatrixKernelEnumerator* enumerator)
        {
            long order = GetTriangularOrder(enumerator);
            long x = x_kernel;
            long y = y_kernel;

            long prefixColumns = x * order - (x * (x - 1L)) / 2L;
            return prefixColumns + (y - x);
        }

        [UnmanagedCallersOnly(CallConvs =[ typeof(CallConvCdecl) ])]
        private static long GetIndexOffsetUpperTriangle(
                            int x_kernel,
                            int y_kernel,
                            MatrixKernelEnumerator* enumerator)
        {
            long x = x_kernel;
            long y = y_kernel;

            long prefixColumns = (x * (x + 1L)) / 2L;
            return prefixColumns + y;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static long GetTriangularOrder(MatrixKernelEnumerator* enumerator)
        {
            return Math.Min(enumerator->KernelColumnLength, enumerator->KernelRowLength);
        }

        [UnmanagedCallersOnly(CallConvs =[ typeof(CallConvCdecl) ])]
        private static bool IsInBufferDenseSquare(
                            int x_kernel,
                            int y_kernel,
                            MatrixKernelEnumerator* enumerator)
        {
            return IsWithinKernelDomain(enumerator, x_kernel, y_kernel);
        }

        [UnmanagedCallersOnly(CallConvs =[ typeof(CallConvCdecl) ])]
        private static bool IsInBufferLowerTriangle(
                            int x_kernel,
                            int y_kernel,
                            MatrixKernelEnumerator* enumerator)
        {
            return IsWithinTriangularDomain(enumerator, x_kernel, y_kernel) && y_kernel >= x_kernel;
        }

        [UnmanagedCallersOnly(CallConvs =[ typeof(CallConvCdecl) ])]
        private static bool IsInBufferUpperTriangle(
                            int x_kernel,
                            int y_kernel,
                            MatrixKernelEnumerator* enumerator)
        {
            return IsWithinTriangularDomain(enumerator, x_kernel, y_kernel) && y_kernel <= x_kernel;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static bool IsWithinKernelDomain(
                            MatrixKernelEnumerator* enumerator,
                            int x_kernel,
                            int y_kernel)
        {
            return x_kernel >= 0 &&
                   y_kernel >= 0 &&
                   x_kernel < enumerator->KernelColumnLength &&
                   y_kernel < enumerator->KernelRowLength;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static bool IsWithinTriangularDomain(
                            MatrixKernelEnumerator* enumerator,
                            int x_kernel,
                            int y_kernel)
        {
            long order = GetTriangularOrder(enumerator);
            return x_kernel >= 0 && y_kernel >= 0 && x_kernel < order && y_kernel < order;
        }

    }

    [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;

        public MatrixSize(
               int elementColumnLength,
               int elementRowLength,
               int kernelColumnLength,
               int kernelRowLength)
        {
            ElementColumnLength = elementColumnLength;
            ElementRowLength = elementRowLength;
            KernelColumnLength = kernelColumnLength;
            KernelRowLength = 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;

    }
}