From 31f649015cfc057459f84ec5093a7d1eb32d7bed Mon Sep 17 00:00:00 2001
From: Youmu Liu <105042599+Nitload-NSI@users.noreply.github.com>
Date: Thu, 9 Oct 2025 20:47:09 +0800
Subject: [PATCH] all public occassions

---
 .../Linear/MatrixParallel.Publish.cs          | 760 +++++++++++++++++-
 1 file changed, 751 insertions(+), 9 deletions(-)

diff --git a/StgSharp.Common/Mathematics/Linear/MatrixParallel.Publish.cs b/StgSharp.Common/Mathematics/Linear/MatrixParallel.Publish.cs
index 0338c129..e79be888 100644
--- a/StgSharp.Common/Mathematics/Linear/MatrixParallel.Publish.cs
+++ b/StgSharp.Common/Mathematics/Linear/MatrixParallel.Publish.cs
@@ -42,6 +42,32 @@ namespace StgSharp.Mathematics
     public static partial class MatrixParallel
     {
 
+        public static unsafe void PublicTask<T>(
+                                  MatrixSegmentEnumeration<T> source,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation)
+            where T: unmanaged, INumber<T>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Right = source.Source;
+            package->Result = ans.Source;
+            package->RightPrimOffset = source.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->RightPrimStride = source.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->RightSecOffset = source.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->RightSecStride = source.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = source.PrimSize;
+            package->SecCount = source.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 1; // Unary
+
+            PublicTaskPrivate<T>(package);
+        }
+
         public static unsafe void PublicTask<T>(
                                   MatrixSegmentEnumeration<T> left,
                                   MatrixSegmentEnumeration<T> right,
@@ -49,11 +75,6 @@ namespace StgSharp.Mathematics
                                   delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation)
             where T: unmanaged, INumber<T>
         {
-            int length = _threads.Length,
-                columnCount = left.PrimSize,
-                rowCount = right.PrimSize;
-            (int c3, int c4) = FastDecompose(columnCount);
-
             MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
             package->Left = left.Source;
             package->Right = right.Source;
@@ -74,11 +95,732 @@ namespace StgSharp.Mathematics
             package->SecCount = left.SecondarySize;
             package->ComputeHandle = (nint)Operation;
             package->ElementSize = sizeof(T);
-            package->ComputeMode = 3;
+            package->ComputeMode = 3; // Binary
 
-            int baseCount = columnCount / length,
-                rem = columnCount % length;
-            if (baseCount == 0) { }
+            PublicTaskPrivate<T>(package);
+        }
+
+        // Unary with 1..8 scalars (each scalar is independent generic type)
+        public static unsafe void PublicTask<T, TScalar0>(
+                                  MatrixSegmentEnumeration<T> source,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Right = source.Source;
+            package->Result = ans.Source;
+            package->RightPrimOffset = source.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->RightPrimStride = source.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->RightSecOffset = source.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->RightSecStride = source.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = source.PrimSize;
+            package->SecCount = source.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 2; // UnaryScalar
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1>(
+                                  MatrixSegmentEnumeration<T> source,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Right = source.Source;
+            package->Result = ans.Source;
+            package->RightPrimOffset = source.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->RightPrimStride = source.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->RightSecOffset = source.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->RightSecStride = source.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = source.PrimSize;
+            package->SecCount = source.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 2;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        // Binary with 1..8 scalars (each scalar is independent generic type)
+        public static unsafe void PublicTask<T, TScalar0>(
+                                  MatrixSegmentEnumeration<T> left,
+                                  MatrixSegmentEnumeration<T> right,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Left = left.Source;
+            package->Right = right.Source;
+            package->Result = ans.Source;
+            package->LeftPrimOffset = left.PrimOffset;
+            package->RightPrimOffset = right.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->LeftPrimStride = left.PrimStride;
+            package->RightPrimStride = right.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->LeftSecOffset = left.SecondaryOffset;
+            package->RightSecOffset = right.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->LeftSecStride = left.SecondaryStride;
+            package->RightSecStride = right.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = left.PrimSize;
+            package->SecCount = left.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 4; // BinaryScalar
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2>(
+                                  MatrixSegmentEnumeration<T> source,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Right = source.Source;
+            package->Result = ans.Source;
+            package->RightPrimOffset = source.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->RightPrimStride = source.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->RightSecOffset = source.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->RightSecStride = source.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = source.PrimSize;
+            package->SecCount = source.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 2;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1>(
+                                  MatrixSegmentEnumeration<T> left,
+                                  MatrixSegmentEnumeration<T> right,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Left = left.Source;
+            package->Right = right.Source;
+            package->Result = ans.Source;
+            package->LeftPrimOffset = left.PrimOffset;
+            package->RightPrimOffset = right.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->LeftPrimStride = left.PrimStride;
+            package->RightPrimStride = right.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->LeftSecOffset = left.SecondaryOffset;
+            package->RightSecOffset = right.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->LeftSecStride = left.SecondaryStride;
+            package->RightSecStride = right.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = left.PrimSize;
+            package->SecCount = left.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 4;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3>(
+                                  MatrixSegmentEnumeration<T> source,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2,
+                                  TScalar3 s3)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+            where TScalar3: unmanaged, INumber<TScalar3>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Right = source.Source;
+            package->Result = ans.Source;
+            package->RightPrimOffset = source.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->RightPrimStride = source.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->RightSecOffset = source.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->RightSecStride = source.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = source.PrimSize;
+            package->SecCount = source.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 2;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            sp->Data<TScalar3>(3) = s3;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2>(
+                                  MatrixSegmentEnumeration<T> left,
+                                  MatrixSegmentEnumeration<T> right,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Left = left.Source;
+            package->Right = right.Source;
+            package->Result = ans.Source;
+            package->LeftPrimOffset = left.PrimOffset;
+            package->RightPrimOffset = right.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->LeftPrimStride = left.PrimStride;
+            package->RightPrimStride = right.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->LeftSecOffset = left.SecondaryOffset;
+            package->RightSecOffset = right.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->LeftSecStride = left.SecondaryStride;
+            package->RightSecStride = right.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = left.PrimSize;
+            package->SecCount = left.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 4;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4>(
+                                  MatrixSegmentEnumeration<T> source,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2,
+                                  TScalar3 s3,
+                                  TScalar4 s4)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+            where TScalar3: unmanaged, INumber<TScalar3>
+            where TScalar4: unmanaged, INumber<TScalar4>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Right = source.Source;
+            package->Result = ans.Source;
+            package->RightPrimOffset = source.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->RightPrimStride = source.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->RightSecOffset = source.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->RightSecStride = source.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = source.PrimSize;
+            package->SecCount = source.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 2;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            sp->Data<TScalar3>(3) = s3;
+            sp->Data<TScalar4>(4) = s4;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3>(
+                                  MatrixSegmentEnumeration<T> left,
+                                  MatrixSegmentEnumeration<T> right,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2,
+                                  TScalar3 s3)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+            where TScalar3: unmanaged, INumber<TScalar3>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Left = left.Source;
+            package->Right = right.Source;
+            package->Result = ans.Source;
+            package->LeftPrimOffset = left.PrimOffset;
+            package->RightPrimOffset = right.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->LeftPrimStride = left.PrimStride;
+            package->RightPrimStride = right.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->LeftSecOffset = left.SecondaryOffset;
+            package->RightSecOffset = right.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->LeftSecStride = left.SecondaryStride;
+            package->RightSecStride = right.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = left.PrimSize;
+            package->SecCount = left.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 4;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            sp->Data<TScalar3>(3) = s3;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5>(
+                                  MatrixSegmentEnumeration<T> source,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2,
+                                  TScalar3 s3,
+                                  TScalar4 s4,
+                                  TScalar5 s5)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+            where TScalar3: unmanaged, INumber<TScalar3>
+            where TScalar4: unmanaged, INumber<TScalar4>
+            where TScalar5: unmanaged, INumber<TScalar5>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Right = source.Source;
+            package->Result = ans.Source;
+            package->RightPrimOffset = source.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->RightPrimStride = source.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->RightSecOffset = source.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->RightSecStride = source.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = source.PrimSize;
+            package->SecCount = source.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 2;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            sp->Data<TScalar3>(3) = s3;
+            sp->Data<TScalar4>(4) = s4;
+            sp->Data<TScalar5>(5) = s5;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4>(
+                                  MatrixSegmentEnumeration<T> left,
+                                  MatrixSegmentEnumeration<T> right,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2,
+                                  TScalar3 s3,
+                                  TScalar4 s4)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+            where TScalar3: unmanaged, INumber<TScalar3>
+            where TScalar4: unmanaged, INumber<TScalar4>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Left = left.Source;
+            package->Right = right.Source;
+            package->Result = ans.Source;
+            package->LeftPrimOffset = left.PrimOffset;
+            package->RightPrimOffset = right.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->LeftPrimStride = left.PrimStride;
+            package->RightPrimStride = right.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->LeftSecOffset = left.SecondaryOffset;
+            package->RightSecOffset = right.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->LeftSecStride = left.SecondaryStride;
+            package->RightSecStride = right.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = left.PrimSize;
+            package->SecCount = left.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 4;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            sp->Data<TScalar3>(3) = s3;
+            sp->Data<TScalar4>(4) = s4;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6>(
+                                  MatrixSegmentEnumeration<T> source,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2,
+                                  TScalar3 s3,
+                                  TScalar4 s4,
+                                  TScalar5 s5,
+                                  TScalar6 s6)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+            where TScalar3: unmanaged, INumber<TScalar3>
+            where TScalar4: unmanaged, INumber<TScalar4>
+            where TScalar5: unmanaged, INumber<TScalar5>
+            where TScalar6: unmanaged, INumber<TScalar6>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Right = source.Source;
+            package->Result = ans.Source;
+            package->RightPrimOffset = source.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->RightPrimStride = source.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->RightSecOffset = source.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->RightSecStride = source.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = source.PrimSize;
+            package->SecCount = source.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 2;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            sp->Data<TScalar3>(3) = s3;
+            sp->Data<TScalar4>(4) = s4;
+            sp->Data<TScalar5>(5) = s5;
+            sp->Data<TScalar6>(6) = s6;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5>(
+                                  MatrixSegmentEnumeration<T> left,
+                                  MatrixSegmentEnumeration<T> right,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2,
+                                  TScalar3 s3,
+                                  TScalar4 s4,
+                                  TScalar5 s5)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+            where TScalar3: unmanaged, INumber<TScalar3>
+            where TScalar4: unmanaged, INumber<TScalar4>
+            where TScalar5: unmanaged, INumber<TScalar5>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Left = left.Source;
+            package->Right = right.Source;
+            package->Result = ans.Source;
+            package->LeftPrimOffset = left.PrimOffset;
+            package->RightPrimOffset = right.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->LeftPrimStride = left.PrimStride;
+            package->RightPrimStride = right.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->LeftSecOffset = left.SecondaryOffset;
+            package->RightSecOffset = right.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->LeftSecStride = left.SecondaryStride;
+            package->RightSecStride = right.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = left.PrimSize;
+            package->SecCount = left.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 4;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            sp->Data<TScalar3>(3) = s3;
+            sp->Data<TScalar4>(4) = s4;
+            sp->Data<TScalar5>(5) = s5;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6, TScalar7>(
+                                  MatrixSegmentEnumeration<T> source,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2,
+                                  TScalar3 s3,
+                                  TScalar4 s4,
+                                  TScalar5 s5,
+                                  TScalar6 s6,
+                                  TScalar7 s7)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+            where TScalar3: unmanaged, INumber<TScalar3>
+            where TScalar4: unmanaged, INumber<TScalar4>
+            where TScalar5: unmanaged, INumber<TScalar5>
+            where TScalar6: unmanaged, INumber<TScalar6>
+            where TScalar7: unmanaged, INumber<TScalar7>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Right = source.Source;
+            package->Result = ans.Source;
+            package->RightPrimOffset = source.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->RightPrimStride = source.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->RightSecOffset = source.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->RightSecStride = source.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = source.PrimSize;
+            package->SecCount = source.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 2;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            sp->Data<TScalar3>(3) = s3;
+            sp->Data<TScalar4>(4) = s4;
+            sp->Data<TScalar5>(5) = s5;
+            sp->Data<TScalar6>(6) = s6;
+            sp->Data<TScalar7>(7) = s7;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6>(
+                                  MatrixSegmentEnumeration<T> left,
+                                  MatrixSegmentEnumeration<T> right,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2,
+                                  TScalar3 s3,
+                                  TScalar4 s4,
+                                  TScalar5 s5,
+                                  TScalar6 s6)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+            where TScalar3: unmanaged, INumber<TScalar3>
+            where TScalar4: unmanaged, INumber<TScalar4>
+            where TScalar5: unmanaged, INumber<TScalar5>
+            where TScalar6: unmanaged, INumber<TScalar6>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Left = left.Source;
+            package->Right = right.Source;
+            package->Result = ans.Source;
+            package->LeftPrimOffset = left.PrimOffset;
+            package->RightPrimOffset = right.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->LeftPrimStride = left.PrimStride;
+            package->RightPrimStride = right.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->LeftSecOffset = left.SecondaryOffset;
+            package->RightSecOffset = right.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->LeftSecStride = left.SecondaryStride;
+            package->RightSecStride = right.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = left.PrimSize;
+            package->SecCount = left.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 4;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            sp->Data<TScalar3>(3) = s3;
+            sp->Data<TScalar4>(4) = s4;
+            sp->Data<TScalar5>(5) = s5;
+            sp->Data<TScalar6>(6) = s6;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        public static unsafe void PublicTask<T, TScalar0, TScalar1, TScalar2, TScalar3, TScalar4, TScalar5, TScalar6, TScalar7>(
+                                  MatrixSegmentEnumeration<T> left,
+                                  MatrixSegmentEnumeration<T> right,
+                                  MatrixSegmentEnumeration<T> ans,
+                                  delegate*<MatrixKernel<T>*, MatrixKernel<T>*, MatrixKernel<T>*, void> Operation,
+                                  TScalar0 s0,
+                                  TScalar1 s1,
+                                  TScalar2 s2,
+                                  TScalar3 s3,
+                                  TScalar4 s4,
+                                  TScalar5 s5,
+                                  TScalar6 s6,
+                                  TScalar7 s7)
+            where T: unmanaged, INumber<T>
+            where TScalar0: unmanaged, INumber<TScalar0>
+            where TScalar1: unmanaged, INumber<TScalar1>
+            where TScalar2: unmanaged, INumber<TScalar2>
+            where TScalar3: unmanaged, INumber<TScalar3>
+            where TScalar4: unmanaged, INumber<TScalar4>
+            where TScalar5: unmanaged, INumber<TScalar5>
+            where TScalar6: unmanaged, INumber<TScalar6>
+            where TScalar7: unmanaged, INumber<TScalar7>
+        {
+            MatrixParallelTaskPackage<T>* package = MatrixParallelFactory.CreateBaseTask<T>();
+            package->Left = left.Source;
+            package->Right = right.Source;
+            package->Result = ans.Source;
+            package->LeftPrimOffset = left.PrimOffset;
+            package->RightPrimOffset = right.PrimOffset;
+            package->ResultPrimOffset = ans.PrimOffset;
+            package->LeftPrimStride = left.PrimStride;
+            package->RightPrimStride = right.PrimStride;
+            package->ResultPrimStride = ans.PrimStride;
+            package->LeftSecOffset = left.SecondaryOffset;
+            package->RightSecOffset = right.SecondaryOffset;
+            package->ResultSecOffset = ans.SecondaryOffset;
+            package->LeftSecStride = left.SecondaryStride;
+            package->RightSecStride = right.SecondaryStride;
+            package->ResultSecStride = ans.SecondaryStride;
+            package->PrimCount = left.PrimSize;
+            package->SecCount = left.SecondarySize;
+            package->ComputeHandle = (nint)Operation;
+            package->ElementSize = sizeof(T);
+            package->ComputeMode = 4;
+            ScalarPacket* sp = MatrixParallelFactory.CreateScalarPacket();
+
+            sp->Data<TScalar0>(0) = s0;
+            sp->Data<TScalar1>(1) = s1;
+            sp->Data<TScalar2>(2) = s2;
+            sp->Data<TScalar3>(3) = s3;
+            sp->Data<TScalar4>(4) = s4;
+            sp->Data<TScalar5>(5) = s5;
+            sp->Data<TScalar6>(6) = s6;
+            sp->Data<TScalar7>(7) = s7;
+            package->Scalar = sp;
+            PublicTaskPrivate<T>(package);
+        }
+
+        private static unsafe void PublicTaskPrivate<T>(MatrixParallelTaskPackage<T>* package)
+            where T: unmanaged, INumber<T>
+        {
+            int primCount = package->PrimCount;
+            int secCount = package->SecCount;
+            int threadPerGroup = (1024 / primCount) + 1;
+            secCount /= threadPerGroup;
         }
 
     }