diff --git a/BrightData.UnitTests/FixedSizeArrayTests.cs b/BrightData.UnitTests/FixedSizeArrayTests.cs
index 5417b825..7e0fec79 100644
--- a/BrightData.UnitTests/FixedSizeArrayTests.cs
+++ b/BrightData.UnitTests/FixedSizeArrayTests.cs
@@ -40,5 +40,18 @@ public void TestDescending()
             array.Size.Should().Be(1);
             array.MaxValue.Should().Be(1);
         }
+
+        [Fact]
+        public void TestSingle()
+        {
+            var array = new FixedSizeSortedAscending1Array<uint, float>();
+            array.TryAdd(1, 0.2f).Should().BeTrue();
+            array.TryAdd(2, 0.3f).Should().BeFalse();
+            array.TryAdd(3, 0.1f).Should().BeTrue();
+            array.MaxValue.Should().Be(array.MinValue);
+            array.MaxWeight.Should().Be(array.MinWeight);
+            array.RemoveAt(0);
+            array.Size.Should().Be(0);
+        }
     }
 }
diff --git a/BrightData.UnitTests/MatrixTests.cs b/BrightData.UnitTests/MatrixTests.cs
index f721fcb2..ad4ecf80 100644
--- a/BrightData.UnitTests/MatrixTests.cs
+++ b/BrightData.UnitTests/MatrixTests.cs
@@ -539,7 +539,7 @@ public void MatrixMultiplyEachColumnWith()
         [Fact]
         public void MatrixSigmoidActivation()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             using var cpu = a.Sigmoid();
             using var gpu = Apply(_cuda, a, (a) => a.Sigmoid());
@@ -550,7 +550,7 @@ public void MatrixSigmoidActivation()
         [Fact]
         public void MatrixSigmoidDerivative()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             using var cpu = a.SigmoidDerivative();
             using var gpu = Apply(_cuda, a, (a) => a.SigmoidDerivative());
@@ -561,7 +561,7 @@ public void MatrixSigmoidDerivative()
         [Fact]
         public void MatrixTanhActivation()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             using var cpu = a.Tanh();
             using var gpu = Apply(_cuda, a, a => a.Tanh());
@@ -572,7 +572,7 @@ public void MatrixTanhActivation()
         [Fact]
         public void MatrixTanhDerivative()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             using var cpu = a.TanhDerivative();
             using var gpu = Apply(_cuda, a, a => a.TanhDerivative());
@@ -583,7 +583,7 @@ public void MatrixTanhDerivative()
         [Fact]
         public void MatrixReluActivation()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             using var cpu = a.Relu();
             using var gpu = Apply(_cuda, a, a => a.Relu());
@@ -594,7 +594,7 @@ public void MatrixReluActivation()
         [Fact]
         public void MatrixReluDerivative()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             using var cpu = a.ReluDerivative();
             using var gpu = Apply(_cuda, a, a => a.ReluDerivative());
@@ -605,7 +605,7 @@ public void MatrixReluDerivative()
         [Fact]
         public void MatrixLeakyReluActivation()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             using var cpu = a.LeakyRelu();
             using var gpu = Apply(_cuda, a, a => a.LeakyRelu());
@@ -616,7 +616,7 @@ public void MatrixLeakyReluActivation()
         [Fact]
         public void MatrixLeakyReluDerivative()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             using var cpu = a.LeakyReluDerivative();
             using var gpu = Apply(_cuda, a, a => a.LeakyReluDerivative());
@@ -627,7 +627,7 @@ public void MatrixLeakyReluDerivative()
         [Fact]
         public void MatrixSoftmaxActivation()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             using var cpu = a.Softmax();
             using var gpu = Apply(_cuda, a, a => a.Softmax());
@@ -638,7 +638,7 @@ public void MatrixSoftmaxActivation()
         [Fact]
         public void MatrixSoftmaxPerRow()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             var cpu = a.SoftmaxPerRow().Select(x => _cpu.CreateVector(x)).ToArray();
             var gpu = Apply(_cuda, a, a => a.SoftmaxPerRow().Select(x => _cuda.CreateVector(x)).ToArray());
@@ -649,7 +649,7 @@ public void MatrixSoftmaxPerRow()
         [Fact]
         public void MatrixRowVector2()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             var cpu = 3.AsRange().Select(a.GetRowVector).ToArray();
             var gpu = Apply(_cuda, a, a => 3.AsRange().Select(a.GetRowVector).ToArray());
@@ -660,7 +660,7 @@ public void MatrixRowVector2()
         [Fact]
         public void MatrixRowVectorsTransposed()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             using var aT = a.Transpose();
             var cpu = 3.AsRange().Select(aT.GetColumnVector).ToArray();
@@ -672,7 +672,7 @@ public void MatrixRowVectorsTransposed()
         [Fact]
         public void MatrixSoftmaxDerivative()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             var cpu = _cpu.SoftmaxDerivative(a.Segment);
             var gpu = Apply(_cuda, a, a => _cuda.SoftmaxDerivative(a.Segment));
@@ -683,7 +683,7 @@ public void MatrixSoftmaxDerivative()
         [Fact]
         public void MatrixSoftmaxPerRowDerivative()
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var a = _cpu.CreateMatrix(3, 7, (j, k) => Convert.ToSingle(normalDistribution.Sample()));
             var cpu = a.SoftmaxPerRow();
             var gpu = Apply(_cuda, a, a => a.SoftmaxPerRow());
@@ -961,7 +961,7 @@ public void MatrixPow()
         [Fact]
         public void MatrixConstrain()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
             using var cpu = _cpu.CreateMatrix(100, 100, (x, y) => Convert.ToSingle(distribution.Sample()));
             using var gpu = Apply(_cuda, cpu, a => a.ConstrainInPlace(-2f, 2f));
             using var mkl = Apply(_mkl, cpu, a => a.ConstrainInPlace(-2f, 2f));
diff --git a/BrightData.UnitTests/TensorTests.cs b/BrightData.UnitTests/TensorTests.cs
index c5d61b42..b688c04e 100644
--- a/BrightData.UnitTests/TensorTests.cs
+++ b/BrightData.UnitTests/TensorTests.cs
@@ -119,7 +119,7 @@ public void TensorAddPadding2()
 
         void CheckTensorIm2Col(uint rows, uint columns, uint depth, uint filterWidth, uint filterHeight, uint xStride, uint yStride, bool randomData)
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var cpuTensor = _cpu.CreateTensor3D(depth.AsRange().Select(i => _cpu.CreateMatrix(rows, columns, (j, k) => randomData
                 ? Convert.ToSingle(normalDistribution.Sample())
                 : Convert.ToSingle((i + 1) * (j + 1) * (k + 1))
@@ -318,7 +318,7 @@ public void TensorMaxPoolBlankIrregular()
 
         void CheckTensorMaxPool(uint rows, uint columns, uint depth, uint filterWidth, uint filterHeight, uint xStride, uint yStride, bool randomInit, bool calculateIndices)
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var cpuTensor = _cpu.CreateTensor3D(depth.AsRange().Select(i => _cpu.CreateMatrix(rows, columns, (j, k) => randomInit
                 ? Convert.ToSingle(normalDistribution.Sample())
                 : Convert.ToSingle((i + 1) * (j + 1) * (k + 1))
@@ -359,7 +359,7 @@ void CheckTensorMaxPool(uint rows, uint columns, uint depth, uint filterWidth, u
 
         void CheckTensorReverseIm2Col(uint filterWidth, uint filterHeight, uint xStride, uint yStride, uint depth, uint filterCount, uint inputWidth, uint inputHeight)
         {
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             using var cpuTensor = _cpu.CreateTensor3D(depth.AsRange().Select(_ => _cpu.CreateMatrix(inputHeight, inputWidth, (_, _) => Convert.ToSingle(normalDistribution.Sample()))).ToArray());
             using var im2Col = cpuTensor.Im2Col(filterWidth, filterHeight, xStride, yStride);
             using var cpuFilter = _cpu.CreateMatrix(depth * filterWidth * filterHeight, filterCount, (_, _) => normalDistribution.Sample());
@@ -793,7 +793,7 @@ public void Tensor3DToFloatTensor()
         [Fact]
         public void Tensor3DTransposeThisAndMultiply()
         {
-            var normalDistribution = _context.CreateNormalDistribution();
+            var normalDistribution = _context.CreateNormalDistribution<float>();
             var tensor1 = CheckCreateTensor(9, 3, 3, (_, _, _) => normalDistribution.Sample());
             var data = 3.AsRange().Select(_ => CheckCreateTensor(3, 3, 3, (i, j, k) => (i + 1) * (j + 1) * (k + 1))).ToArray();
 
@@ -814,7 +814,7 @@ public void Tensor3DTransposeThisAndMultiply()
         [Fact]
         public void Tensor3DMultiply()
         {
-            var normalDistribution = _context.CreateNormalDistribution();
+            var normalDistribution = _context.CreateNormalDistribution<float>();
             var tensor1 = CheckCreateTensor(3, 9, 3, (_, _, _) => normalDistribution.Sample());
             var data = 3.AsRange().Select(_ => CheckCreateTensor(3, 3, 3, (i, j, k) => (i + 1) * (j + 1) * (k + 1))).ToArray();
 
@@ -900,7 +900,7 @@ public void Tensor4DReverseIm2Col()
         {
             const int rows = 4, columns = 4, depth = 1, count = 1, filterWidth = 2, filterHeight = 2, filterCount = 1, xStride = 2, yStride = 2;
 
-            var normalDistribution = _context.CreateNormalDistribution(0, 1);
+            var normalDistribution = _context.CreateNormalDistribution<float>(0, 1);
             var data = Enumerable.Range(0, count)
                 .Select(_ => CheckCreateTensor(rows, columns, depth, (_, _, _) => normalDistribution.Sample())).ToArray();
             using var cpuTensor = _cpu.CreateTensor4D(data);
diff --git a/BrightData.UnitTests/VectorTests.cs b/BrightData.UnitTests/VectorTests.cs
index d7813939..8e333a94 100644
--- a/BrightData.UnitTests/VectorTests.cs
+++ b/BrightData.UnitTests/VectorTests.cs
@@ -76,7 +76,7 @@ public void TestVectorCreation()
 
         void TestDistances(DistanceMetric distanceMetric)
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
             var vectors = Enumerable.Range(0, 10).Select(_ => (IReadOnlyNumericSegment<float>)_cpu.CreateSegment(100, _ => distribution.Sample())).ToArray();
             var compareTo = Enumerable.Range(0, 20).Select(_ => (IReadOnlyNumericSegment<float>)_cpu.CreateSegment(100, _ => distribution.Sample())).ToArray();
 
@@ -313,7 +313,7 @@ public void VectorMultiply()
         [Fact]
         public void VectorEuclideanDistance()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(500, _ => distribution.Sample());
             using var b = _cpu.CreateVector(500, _ => distribution.Sample());
@@ -340,7 +340,7 @@ public void VectorCosineDistance()
         [Fact]
         public void VectorManhattanDistance()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(5000, _ => distribution.Sample());
             using var b = _cpu.CreateVector(5000, _ => distribution.Sample());
@@ -354,7 +354,7 @@ public void VectorManhattanDistance()
         [Fact]
         public void VectorMeanSquaredDistance()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(1000, _ => distribution.Sample());
             using var b = _cpu.CreateVector(1000, _ => distribution.Sample());
@@ -367,7 +367,7 @@ public void VectorMeanSquaredDistance()
         [Fact]
         public void VectorSquaredEuclideanDistance()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(1000, _ => distribution.Sample());
             using var b = _cpu.CreateVector(1000, _ => distribution.Sample());
@@ -381,7 +381,7 @@ public void VectorSquaredEuclideanDistance()
         [Fact]
         public void VectorAverage()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(5000, _ => distribution.Sample());
             var cpu = a.Average();
@@ -393,7 +393,7 @@ public void VectorAverage()
         [Fact]
         public void VectorL1Norm()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(5000, _ => distribution.Sample());
             var cpu = a.L1Norm();
@@ -405,7 +405,7 @@ public void VectorL1Norm()
         [Fact]
         public void VectorAbs()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(5000, _ => distribution.Sample());
             var cpu = a.Abs();
@@ -417,7 +417,7 @@ public void VectorAbs()
         [Fact]
         public void VectorLog()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(5000, _ => distribution.Sample());
             var cpu = a.Log();
@@ -430,7 +430,7 @@ public void VectorLog()
         [Fact]
         public void VectorStdDev()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(5000, _ => distribution.Sample());
             var cpu = a.StdDev(null);
@@ -493,7 +493,7 @@ static IVector<float> TestMultiDistance(LinearAlgebraProvider<float> lap, IVecto
         [Fact]
         public void MultiEuclideanDistance()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(5000, _ => distribution.Sample());
             using var b = _cpu.CreateVector(5000, _ => distribution.Sample());
@@ -507,7 +507,7 @@ public void MultiEuclideanDistance()
         [Fact]
         public void MultiManhattanDistance()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(5000, _ => distribution.Sample());
             using var b = _cpu.CreateVector(5000, _ => distribution.Sample());
@@ -520,7 +520,7 @@ public void MultiManhattanDistance()
         [Fact]
         public void MultiCosineDistance()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
 
             using var a = _cpu.CreateVector(5000, _ => distribution.Sample());
             using var b = _cpu.CreateVector(5000, _ => distribution.Sample());
@@ -623,7 +623,7 @@ public void VectorSplit()
         [Fact]
         public void VectorSoftMax()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
             using var a = _cpu.CreateVector(128, _ => distribution.Sample());
             using var cpu = a.Softmax();
 
@@ -635,7 +635,7 @@ public void VectorSoftMax()
         [Fact]
         public void VectorSoftMaxDerivative()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
             using var a = _cpu.CreateVector(128, _ => distribution.Sample());
             using var cpu = a.SoftmaxDerivative();
 
@@ -650,7 +650,7 @@ public void VectorSoftMaxDerivative()
         [Fact]
         public void VectorReverse()
         {
-            var distribution = _context.CreateNormalDistribution(0, 5);
+            var distribution = _context.CreateNormalDistribution<float>(0, 5);
             var a = _cpu.CreateVector(128, _ => distribution.Sample());
             var cpu = a.Reverse();
 
diff --git a/BrightData/BrightData.csproj b/BrightData/BrightData.csproj
index 507b41de..ad81d5e3 100644
--- a/BrightData/BrightData.csproj
+++ b/BrightData/BrightData.csproj
@@ -63,11 +63,6 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>GenericTypeMapping.tt</DependentUpon>
     </None>
-    <None Include="Types\FixedSizeSortedArray\FixedSizeSortedArray.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>FixedSizeSortedArray.tt</DependentUpon>
-    </None>
   </ItemGroup>
 
   <ItemGroup>
@@ -87,6 +82,10 @@
       <Pack>True</Pack>
       <PackagePath>\</PackagePath>
     </None>
+    <None Update="Types\FixedSizeSortedArray\FixedSizeSortedArrayTemplate.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>FixedSizeSortedArrayTemplate.cs</LastGenOutput>
+    </None>
     <None Update="Types\FixedSizeSortedArray\FixedSizeSortedArray.tt">
       <Generator>TextTemplatingFileGenerator</Generator>
       <LastGenOutput>FixedSizeSortedArray.cs</LastGenOutput>
@@ -113,10 +112,14 @@
       <AutoGen>True</AutoGen>
       <DependentUpon>GenericTypeMapping.tt</DependentUpon>
     </Compile>
-    <Compile Update="Types\FixedSizeSortedArray\FixedSizeSortedArray.cs">
+    <Compile Update="Types\Helper\SortedArrayHelper.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+    </Compile>
+    <Compile Update="Types\FixedSizeSortedArray\FixedSizeSortedArrayTemplate.cs">
       <DesignTime>True</DesignTime>
       <AutoGen>True</AutoGen>
-      <DependentUpon>FixedSizeSortedArray.tt</DependentUpon>
+      <DependentUpon>FixedSizeSortedArrayTemplate.tt</DependentUpon>
     </Compile>
   </ItemGroup>
 </Project>
diff --git a/BrightData/BrightData.xml b/BrightData/BrightData.xml
index a977f713..18c57f58 100644
--- a/BrightData/BrightData.xml
+++ b/BrightData/BrightData.xml
@@ -4031,7 +4031,7 @@
             <param name="categoricalValues"></param>
             <returns></returns>
         </member>
-        <member name="M:BrightData.ExtensionMethods.CreateContinuousDistribution(BrightData.BrightDataContext,System.Single,System.Single)">
+        <member name="M:BrightData.ExtensionMethods.CreateContinuousDistribution``1(BrightData.BrightDataContext,System.Nullable{``0},System.Nullable{``0})">
             <summary>
             Create a continuous distribution
             </summary>
@@ -4049,7 +4049,7 @@
             <param name="exclusiveUpperBound"></param>
             <returns></returns>
         </member>
-        <member name="M:BrightData.ExtensionMethods.CreateNormalDistribution(BrightData.BrightDataContext,System.Single,System.Single)">
+        <member name="M:BrightData.ExtensionMethods.CreateNormalDistribution``1(BrightData.BrightDataContext,System.Nullable{``0},System.Nullable{``0})">
             <summary>
             Create a normal distribution
             </summary>
@@ -4058,7 +4058,7 @@
             <param name="stdDev">Standard deviation</param>
             <returns></returns>
         </member>
-        <member name="M:BrightData.ExtensionMethods.CreateExponentialDistribution(BrightData.BrightDataContext,System.Single)">
+        <member name="M:BrightData.ExtensionMethods.CreateExponentialDistribution``1(BrightData.BrightDataContext,System.Nullable{``0})">
             <summary>
             Create an exponential distribution
             </summary>
@@ -5741,7 +5741,7 @@
             Categorical distribution - https://en.wikipedia.org/wiki/Categorical_distribution
             </summary>
         </member>
-        <member name="T:BrightData.Distribution.ContinuousDistribution">
+        <member name="T:BrightData.Distribution.ContinuousDistribution`1">
             <summary>
             Continuous distribution - https://en.wikipedia.org/wiki/Probability_distribution#Absolutely_continuous_probability_distribution
             </summary>
@@ -5751,7 +5751,7 @@
             Discrete uniform distribution - https://en.wikipedia.org/wiki/Discrete_uniform_distribution
             </summary>
         </member>
-        <member name="T:BrightData.Distribution.NormalDistribution">
+        <member name="T:BrightData.Distribution.NormalDistribution`1">
             <summary>
             Normal distribution - https://en.wikipedia.org/wiki/Normal_distribution
             </summary>
@@ -5759,7 +5759,7 @@
             <param name="mean"></param>
             <param name="stdDev"></param>
         </member>
-        <member name="M:BrightData.Distribution.NormalDistribution.#ctor(BrightData.BrightDataContext,System.Single,System.Single)">
+        <member name="M:BrightData.Distribution.NormalDistribution`1.#ctor(BrightData.BrightDataContext,System.Nullable{`0},System.Nullable{`0})">
             <summary>
             Normal distribution - https://en.wikipedia.org/wiki/Normal_distribution
             </summary>
@@ -6570,7 +6570,7 @@
             Positive discrete data distribution
             </summary>
         </member>
-        <member name="T:BrightData.IContinuousDistribution">
+        <member name="T:BrightData.IContinuousDistribution`1">
             <summary>
             Continuous data distribution
             </summary>
@@ -12447,6 +12447,172 @@
         <member name="P:BrightData.Types.BinaryData.ReadOnlyMemory">
             <inheritdoc />
         </member>
+        <member name="T:BrightData.Types.FixedSizeSortedAscending1Array`2">
+            <summary>
+            Fixed size sorted array of values and weights (max 1 elements)
+            that is sorted in ascending order based on each weight
+            </summary>
+            <typeparam name="V">Type of value to store</typeparam>
+            <typeparam name="W">Type of weight that will be used to sort</typeparam>
+        </member>
+        <member name="M:BrightData.Types.FixedSizeSortedAscending1Array`2.#ctor">
+            <summary>
+            Fixed size sorted array of values and weights (max 1 elements)
+            that is sorted in ascending order based on each weight
+            </summary>
+            <typeparam name="V">Type of value to store</typeparam>
+            <typeparam name="W">Type of weight that will be used to sort</typeparam>
+        </member>
+        <member name="F:BrightData.Types.FixedSizeSortedAscending1Array`2.MaxSize">
+            <summary>
+            Max size of the array
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedAscending1Array`2.Size">
+            <summary>
+            Current number of elements
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedAscending1Array`2.Values">
+            <summary>
+            Sorted list of values
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedAscending1Array`2.Weights">
+            <summary>
+            Sorted list of weights
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedAscending1Array`2.MinWeight">
+            <summary>
+            The smallest weight
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedAscending1Array`2.MaxWeight">
+            <summary>
+            The largest weight
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedAscending1Array`2.MinValue">
+            <summary>
+            The value with the smallest weight
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedAscending1Array`2.MaxValue">
+            <summary>
+            The value with the largest weight
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedAscending1Array`2.Item(System.Byte)">
+            <summary>
+            Returns a value and weight
+            </summary>
+            <param name="index">Index to return</param>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedAscending1Array`2.Elements">
+            <summary>
+            Enumerates the values and weights
+            </summary>
+        </member>
+        <member name="M:BrightData.Types.FixedSizeSortedAscending1Array`2.TryAdd(`0,`1,System.Boolean)">
+            <summary>
+            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            </summary>
+            <param name="value">Value to add</param>
+            <param name="weight">Weight to add</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
+            <returns>True if the element was added</returns>
+        </member>
+        <member name="M:BrightData.Types.FixedSizeSortedAscending1Array`2.RemoveAt(System.Byte)">
+            <summary>
+            Removes an element from the array
+            </summary>
+            <param name="index">Index of element to remove</param>
+            <exception cref="T:System.ArgumentOutOfRangeException"></exception>
+        </member>
+        <member name="T:BrightData.Types.FixedSizeSortedDescending1Array`2">
+            <summary>
+            Fixed size sorted array of values and weights (max 1 elements)
+            that is sorted in descending order based on each weight
+            </summary>
+            <typeparam name="V">Type of value to store</typeparam>
+            <typeparam name="W">Type of weight that will be used to sort</typeparam>
+        </member>
+        <member name="M:BrightData.Types.FixedSizeSortedDescending1Array`2.#ctor">
+            <summary>
+            Fixed size sorted array of values and weights (max 1 elements)
+            that is sorted in descending order based on each weight
+            </summary>
+            <typeparam name="V">Type of value to store</typeparam>
+            <typeparam name="W">Type of weight that will be used to sort</typeparam>
+        </member>
+        <member name="F:BrightData.Types.FixedSizeSortedDescending1Array`2.MaxSize">
+            <summary>
+            Max size of the array
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedDescending1Array`2.Size">
+            <summary>
+            Current number of elements
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedDescending1Array`2.Values">
+            <summary>
+            Sorted list of values
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedDescending1Array`2.Weights">
+            <summary>
+            Sorted list of weights
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedDescending1Array`2.MinWeight">
+            <summary>
+            The smallest weight
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedDescending1Array`2.MaxWeight">
+            <summary>
+            The largest weight
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedDescending1Array`2.MinValue">
+            <summary>
+            The value with the smallest weight
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedDescending1Array`2.MaxValue">
+            <summary>
+            The value with the largest weight
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedDescending1Array`2.Item(System.Byte)">
+            <summary>
+            Returns a value and weight
+            </summary>
+            <param name="index">Index to return</param>
+        </member>
+        <member name="P:BrightData.Types.FixedSizeSortedDescending1Array`2.Elements">
+            <summary>
+            Enumerates the values and weights
+            </summary>
+        </member>
+        <member name="M:BrightData.Types.FixedSizeSortedDescending1Array`2.TryAdd(`0,`1,System.Boolean)">
+            <summary>
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
+            </summary>
+            <param name="value">Value to add</param>
+            <param name="weight">Weight to add</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
+            <returns>True if the element was added</returns>
+        </member>
+        <member name="M:BrightData.Types.FixedSizeSortedDescending1Array`2.RemoveAt(System.Byte)">
+            <summary>
+            Removes an element from the array
+            </summary>
+            <param name="index">Index of element to remove</param>
+            <exception cref="T:System.ArgumentOutOfRangeException"></exception>
+        </member>
         <member name="T:BrightData.Types.FixedSizeSortedAscending2Array`2">
             <summary>
             Fixed size sorted array of values and weights (max 2 elements)
@@ -12520,7 +12686,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending2Array`2.RemoveAt(System.Byte)">
@@ -12599,11 +12765,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending2Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending2Array`2.RemoveAt(System.Byte)">
@@ -12686,7 +12852,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending3Array`2.RemoveAt(System.Byte)">
@@ -12765,11 +12931,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending3Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending3Array`2.RemoveAt(System.Byte)">
@@ -12852,7 +13018,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending4Array`2.RemoveAt(System.Byte)">
@@ -12931,11 +13097,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending4Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending4Array`2.RemoveAt(System.Byte)">
@@ -13018,7 +13184,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending5Array`2.RemoveAt(System.Byte)">
@@ -13097,11 +13263,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending5Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending5Array`2.RemoveAt(System.Byte)">
@@ -13184,7 +13350,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending6Array`2.RemoveAt(System.Byte)">
@@ -13263,11 +13429,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending6Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending6Array`2.RemoveAt(System.Byte)">
@@ -13350,7 +13516,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending7Array`2.RemoveAt(System.Byte)">
@@ -13429,11 +13595,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending7Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending7Array`2.RemoveAt(System.Byte)">
@@ -13516,7 +13682,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending8Array`2.RemoveAt(System.Byte)">
@@ -13595,11 +13761,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending8Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending8Array`2.RemoveAt(System.Byte)">
@@ -13682,7 +13848,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending9Array`2.RemoveAt(System.Byte)">
@@ -13761,11 +13927,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending9Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending9Array`2.RemoveAt(System.Byte)">
@@ -13848,7 +14014,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending10Array`2.RemoveAt(System.Byte)">
@@ -13927,11 +14093,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending10Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending10Array`2.RemoveAt(System.Byte)">
@@ -14014,7 +14180,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending11Array`2.RemoveAt(System.Byte)">
@@ -14093,11 +14259,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending11Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending11Array`2.RemoveAt(System.Byte)">
@@ -14180,7 +14346,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending12Array`2.RemoveAt(System.Byte)">
@@ -14259,11 +14425,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending12Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending12Array`2.RemoveAt(System.Byte)">
@@ -14346,7 +14512,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending13Array`2.RemoveAt(System.Byte)">
@@ -14425,11 +14591,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending13Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending13Array`2.RemoveAt(System.Byte)">
@@ -14512,7 +14678,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending14Array`2.RemoveAt(System.Byte)">
@@ -14591,11 +14757,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending14Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending14Array`2.RemoveAt(System.Byte)">
@@ -14678,7 +14844,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending15Array`2.RemoveAt(System.Byte)">
@@ -14757,11 +14923,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending15Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending15Array`2.RemoveAt(System.Byte)">
@@ -14844,7 +15010,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending16Array`2.RemoveAt(System.Byte)">
@@ -14923,11 +15089,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending16Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending16Array`2.RemoveAt(System.Byte)">
@@ -15010,7 +15176,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending17Array`2.RemoveAt(System.Byte)">
@@ -15089,11 +15255,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending17Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending17Array`2.RemoveAt(System.Byte)">
@@ -15176,7 +15342,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending18Array`2.RemoveAt(System.Byte)">
@@ -15255,11 +15421,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending18Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending18Array`2.RemoveAt(System.Byte)">
@@ -15342,7 +15508,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending19Array`2.RemoveAt(System.Byte)">
@@ -15421,11 +15587,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending19Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending19Array`2.RemoveAt(System.Byte)">
@@ -15508,7 +15674,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending20Array`2.RemoveAt(System.Byte)">
@@ -15587,11 +15753,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending20Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending20Array`2.RemoveAt(System.Byte)">
@@ -15674,7 +15840,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending21Array`2.RemoveAt(System.Byte)">
@@ -15753,11 +15919,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending21Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending21Array`2.RemoveAt(System.Byte)">
@@ -15840,7 +16006,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending22Array`2.RemoveAt(System.Byte)">
@@ -15919,11 +16085,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending22Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending22Array`2.RemoveAt(System.Byte)">
@@ -16006,7 +16172,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending23Array`2.RemoveAt(System.Byte)">
@@ -16085,11 +16251,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending23Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending23Array`2.RemoveAt(System.Byte)">
@@ -16172,7 +16338,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending24Array`2.RemoveAt(System.Byte)">
@@ -16251,11 +16417,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending24Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending24Array`2.RemoveAt(System.Byte)">
@@ -16338,7 +16504,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending25Array`2.RemoveAt(System.Byte)">
@@ -16417,11 +16583,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending25Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending25Array`2.RemoveAt(System.Byte)">
@@ -16504,7 +16670,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending26Array`2.RemoveAt(System.Byte)">
@@ -16583,11 +16749,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending26Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending26Array`2.RemoveAt(System.Byte)">
@@ -16670,7 +16836,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending27Array`2.RemoveAt(System.Byte)">
@@ -16749,11 +16915,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending27Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending27Array`2.RemoveAt(System.Byte)">
@@ -16836,7 +17002,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending28Array`2.RemoveAt(System.Byte)">
@@ -16915,11 +17081,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending28Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending28Array`2.RemoveAt(System.Byte)">
@@ -17002,7 +17168,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending29Array`2.RemoveAt(System.Byte)">
@@ -17081,11 +17247,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending29Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending29Array`2.RemoveAt(System.Byte)">
@@ -17168,7 +17334,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending30Array`2.RemoveAt(System.Byte)">
@@ -17247,11 +17413,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending30Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending30Array`2.RemoveAt(System.Byte)">
@@ -17334,7 +17500,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending31Array`2.RemoveAt(System.Byte)">
@@ -17413,11 +17579,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending31Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending31Array`2.RemoveAt(System.Byte)">
@@ -17500,7 +17666,7 @@
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedAscending32Array`2.RemoveAt(System.Byte)">
@@ -17579,11 +17745,11 @@
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending32Array`2.TryAdd(`0,`1,System.Boolean)">
             <summary>
-            Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+            Tries to add a new element - will succeed if there aren't already max elements with a higher weight
             </summary>
             <param name="value">Value to add</param>
             <param name="weight">Weight to add</param>
-            <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+            <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
             <returns>True if the element was added</returns>
         </member>
         <member name="M:BrightData.Types.FixedSizeSortedDescending32Array`2.RemoveAt(System.Byte)">
@@ -17593,6 +17759,94 @@
             <param name="index">Index of element to remove</param>
             <exception cref="T:System.ArgumentOutOfRangeException"></exception>
         </member>
+        <member name="T:BrightData.Types.Graph.FixedSizeWeightedGraph`3">
+            <summary>
+            A fixed size graph weighted graph
+            </summary>
+            <typeparam name="T"></typeparam>
+            <typeparam name="W"></typeparam>
+            <typeparam name="AT"></typeparam>
+        </member>
+        <member name="M:BrightData.Types.Graph.FixedSizeWeightedGraph`3.Create(`0,System.Boolean)">
+            <inheritdoc />
+        </member>
+        <member name="M:BrightData.Types.Graph.FixedSizeWeightedGraph`3.Add(BrightData.IWeightedGraphNode{`0,`1})">
+            <inheritdoc />
+        </member>
+        <member name="P:BrightData.Types.Graph.FixedSizeWeightedGraph`3.Size">
+            <inheritdoc />
+        </member>
+        <member name="M:BrightData.Types.Graph.FixedSizeWeightedGraph`3.Get(System.UInt32)">
+            <inheritdoc />
+        </member>
+        <member name="M:BrightData.Types.Graph.FixedSizeWeightedGraph`3.Search``2(System.UInt32,System.UInt32,BrightData.ICalculateNodeWeights{`1})">
+            <inheritdoc />
+        </member>
+        <member name="T:BrightData.Types.Graph.FixedSizeWeightedGraphNode`3">
+            <summary>
+            A graph node with a (fixed size) maximum number of neighbours
+            </summary>
+        </member>
+        <member name="M:BrightData.Types.Graph.FixedSizeWeightedGraphNode`3.#ctor(`0)">
+            <summary>
+            A graph node with a (fixed size) maximum number of neighbours
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.Graph.FixedSizeWeightedGraphNode`3.Index">
+            <inheritdoc />
+        </member>
+        <member name="M:BrightData.Types.Graph.FixedSizeWeightedGraphNode`3.AddNeighbour(System.UInt32,`1)">
+            <summary>
+            Tries to add a new neighbour
+            </summary>
+            <param name="index">Index of neighbour</param>
+            <param name="weight">Neighbour weight</param>
+        </member>
+        <member name="P:BrightData.Types.Graph.FixedSizeWeightedGraphNode`3.WeightedNeighbours">
+            <inheritdoc />
+        </member>
+        <member name="P:BrightData.Types.Graph.FixedSizeWeightedGraphNode`3.NeighbourSpan">
+            <summary>
+            Ordered span of neighbours by weight
+            </summary>
+        </member>
+        <member name="P:BrightData.Types.Graph.FixedSizeWeightedGraphNode`3.Neighbours">
+            <summary>
+            Enumerates the neighbours by weight
+            </summary>
+        </member>
+        <member name="M:BrightData.Types.Graph.FixedSizeWeightedGraphNode`3.CompareTo(BrightData.Types.Graph.FixedSizeWeightedGraphNode{`0,`1,`2})">
+            <inheritdoc />
+        </member>
+        <member name="M:BrightData.Types.Graph.FixedSizeWeightedGraphNode`3.ToString">
+            <inheritdoc />
+        </member>
+        <member name="T:BrightData.Types.Graph.GraphNodeIndex">
+            <summary>
+            Index only graph node value
+            </summary>
+            <param name="Index"></param>
+        </member>
+        <member name="M:BrightData.Types.Graph.GraphNodeIndex.#ctor(System.UInt32)">
+            <summary>
+            Index only graph node value
+            </summary>
+            <param name="Index"></param>
+        </member>
+        <member name="P:BrightData.Types.Graph.GraphNodeIndex.Index">
+            <summary></summary>
+        </member>
+        <member name="M:BrightData.Types.Graph.GraphNodeIndex.CompareTo(BrightData.Types.Graph.GraphNodeIndex)">
+            <inheritdoc />
+        </member>
+        <member name="M:BrightData.Types.Graph.GraphNodeIndex.ToString">
+            <inheritdoc />
+        </member>
+        <member name="T:BrightData.Types.Helper.SortedArrayHelper">
+            <summary>
+            Fixed size array helper methods
+            </summary>
+        </member>
         <member name="T:BrightData.Types.IndexList">
             <summary>
             Contains a list of indices
diff --git a/BrightData/Distribution/ContinuousDistribution.cs b/BrightData/Distribution/ContinuousDistribution.cs
index ea108f7a..9fb6f749 100644
--- a/BrightData/Distribution/ContinuousDistribution.cs
+++ b/BrightData/Distribution/ContinuousDistribution.cs
@@ -1,27 +1,29 @@
 using System;
+using System.Numerics;
 
 namespace BrightData.Distribution
 {
     /// <summary>
     /// Continuous distribution - https://en.wikipedia.org/wiki/Probability_distribution#Absolutely_continuous_probability_distribution
     /// </summary>
-    internal class ContinuousDistribution : IContinuousDistribution
+    internal class ContinuousDistribution<T> : IContinuousDistribution<T>
+        where T : unmanaged, INumber<T>, IBinaryFloatingPointIeee754<T>
     {
         readonly BrightDataContext _context;
 
-        public ContinuousDistribution(BrightDataContext context, float inclusiveLowerBound = 0f, float exclusiveUpperBound = 1f)
+        public ContinuousDistribution(BrightDataContext context, T? inclusiveLowerBound = null, T? exclusiveUpperBound = null)
         {
             if (inclusiveLowerBound > exclusiveUpperBound)
                 throw new ArgumentException("Lower bound was higher than upper bound");
 
             _context = context;
-            From = inclusiveLowerBound;
-            Size = exclusiveUpperBound - inclusiveLowerBound;
+            From = inclusiveLowerBound ?? T.Zero;
+            Size = (exclusiveUpperBound ?? T.One) - From;
         }
 
-        public float From { get; }
-        public float Size { get; }
+        public T From { get; }
+        public T Size { get; }
 
-        public float Sample() => From + _context.NextRandomFloat() * Size;
+        public T Sample() => From + _context.NextRandom<T>() * Size;
     }
 }
diff --git a/BrightData/Distribution/ExponentialDistribution.cs b/BrightData/Distribution/ExponentialDistribution.cs
index a6ee0b6f..e2a6ed31 100644
--- a/BrightData/Distribution/ExponentialDistribution.cs
+++ b/BrightData/Distribution/ExponentialDistribution.cs
@@ -1,20 +1,24 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Numerics;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace BrightData.Distribution
 {
-    internal class ExponentialDistribution(BrightDataContext context, float lambda) : IContinuousDistribution
+    internal class ExponentialDistribution<T>(BrightDataContext context, T? lambda) : IContinuousDistribution<T>
+        where T : unmanaged, INumber<T>, IBinaryFloatingPointIeee754<T>
     {
-        public float Sample()
+        public T Lambda { get; } = lambda ?? T.One;
+
+        public T Sample()
         {
-            float r;
+            T r;
             do {
-                r = context.NextRandomFloat();
-            } while (r == 0f);
-            return -MathF.Log(r) / lambda;
+                r = context.NextRandom<T>();
+            } while (r == T.Zero);
+            return -T.Log(r) * Lambda;
         }
     }
 }
diff --git a/BrightData/Distribution/NormalDistribution.cs b/BrightData/Distribution/NormalDistribution.cs
index fb4bcbcd..c658e773 100644
--- a/BrightData/Distribution/NormalDistribution.cs
+++ b/BrightData/Distribution/NormalDistribution.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Numerics;
 using BrightData.Helper;
 
 namespace BrightData.Distribution
@@ -9,34 +10,35 @@ namespace BrightData.Distribution
     /// <param name="context"></param>
     /// <param name="mean"></param>
     /// <param name="stdDev"></param>
-    internal class NormalDistribution(BrightDataContext context, float mean = 0f, float stdDev = 1f)
-        : IContinuousDistribution
+    internal class NormalDistribution<T>(BrightDataContext context, T? mean = null, T? stdDev = null) : IContinuousDistribution<T>
+        where T: unmanaged, INumber<T>, IBinaryFloatingPointIeee754<T>
     {
-        public float Mean { get; } = mean;
-        public float StdDev { get; } = stdDev;
+        public T Mean { get; } = mean ?? T.Zero;
+        public T StdDev { get; } = stdDev ?? T.One;
 
-        public float Sample()
+        public T Sample()
         {
-            float x;
-            while (!PolarTransform(context.NextRandomFloat(), context.NextRandomFloat(), out x, out _)) {
+            T x;
+            while (!PolarTransform(context.NextRandom<T>(), context.NextRandom<T>(), out x, out _)) {
                 // nop
             }
 
             return Mean + StdDev * x;
         }
 
-        static bool PolarTransform(float a, float b, out float x, out float y)
+        static bool PolarTransform(T a, T b, out T x, out T y)
         {
-            var v1 = (2.0f * a) - 1.0f;
-            var v2 = (2.0f * b) - 1.0f;
+            var two = T.One + T.One;
+            var v1 = (two * a) - T.One;
+            var v2 = (two * b) - T.One;
             var r = (v1 * v1) + (v2 * v2);
-            if (r >= 1.0 || MathF.Abs(r) < Math<float>.AlmostZero) {
-                x = 0;
-                y = 0;
+            if (r >= T.One || T.Abs(r) < Math<T>.AlmostZero) {
+                x = T.Zero;
+                y = T.Zero;
                 return false;
             }
 
-            var fac = MathF.Sqrt(-2.0f * MathF.Log(r) / r);
+            var fac = T.Sqrt(-two * T.Log(r) / r);
             x = v1 * fac;
             y = v2 * fac;
             return true;
diff --git a/BrightData/ExtensionMethods.Distributions.cs b/BrightData/ExtensionMethods.Distributions.cs
index 5fbbbb91..efb4f436 100644
--- a/BrightData/ExtensionMethods.Distributions.cs
+++ b/BrightData/ExtensionMethods.Distributions.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Numerics;
 using BrightData.Distribution;
 
 namespace BrightData
@@ -12,6 +13,8 @@ public partial class ExtensionMethods
         /// <returns></returns>
         public static float NextRandomFloat(this BrightDataContext context) => (float)context.Random.NextDouble();
 
+        public static T NextRandom<T>(this BrightDataContext context) where T: unmanaged, INumber<T> => T.CreateSaturating(context.Random.NextDouble());
+
         /// <summary>
         /// Returns a randomly initialized positive number
         /// </summary>
@@ -60,7 +63,7 @@ public partial class ExtensionMethods
         /// <param name="inclusiveLowerBound"></param>
         /// <param name="exclusiveUpperBound"></param>
         /// <returns></returns>
-        public static IContinuousDistribution CreateContinuousDistribution(this BrightDataContext context, float inclusiveLowerBound = 0f, float exclusiveUpperBound = 1f) => new ContinuousDistribution(context, inclusiveLowerBound, exclusiveUpperBound);
+        public static IContinuousDistribution<T> CreateContinuousDistribution<T>(this BrightDataContext context, T? inclusiveLowerBound = null, T? exclusiveUpperBound = null) where T: unmanaged, INumber<T>, IBinaryFloatingPointIeee754<T> => new ContinuousDistribution<T>(context, inclusiveLowerBound, exclusiveUpperBound);
 
         /// <summary>
         /// Create a discrete uniform distribution
@@ -78,7 +81,7 @@ public partial class ExtensionMethods
         /// <param name="mean"></param>
         /// <param name="stdDev">Standard deviation</param>
         /// <returns></returns>
-        public static IContinuousDistribution CreateNormalDistribution(this BrightDataContext context, float mean = 0f, float stdDev = 1f) => new NormalDistribution(context, mean, stdDev);
+        public static IContinuousDistribution<T> CreateNormalDistribution<T>(this BrightDataContext context, T? mean = null, T? stdDev = null) where T: unmanaged, INumber<T>, IBinaryFloatingPointIeee754<T> => new NormalDistribution<T>(context, mean, stdDev);
 
         /// <summary>
         /// Create an exponential distribution
@@ -86,6 +89,6 @@ public partial class ExtensionMethods
         /// <param name="context"></param>
         /// <param name="lambda"></param>
         /// <returns></returns>
-        public static IContinuousDistribution CreateExponentialDistribution(this BrightDataContext context, float lambda = 1f) => new ExponentialDistribution(context, lambda);
+        public static IContinuousDistribution<T> CreateExponentialDistribution<T>(this BrightDataContext context, T? lambda = null) where T: unmanaged, INumber<T>, IBinaryFloatingPointIeee754<T> => new ExponentialDistribution<T>(context, lambda);
     }
 }
diff --git a/BrightData/Interfaces.cs b/BrightData/Interfaces.cs
index 8b9cde82..d42f627e 100644
--- a/BrightData/Interfaces.cs
+++ b/BrightData/Interfaces.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Numerics;
 using System.Threading;
 using System.Threading.Tasks;
 using BrightData.Types;
@@ -301,7 +302,7 @@ public enum AggregationType
     /// </summary>
     /// <typeparam name="T"></typeparam>
     public interface IDistribution<out T>
-        where T : struct
+        where T : unmanaged, INumber<T>
     {
         /// <summary>
         /// Samples a value from the distribution
@@ -323,7 +324,7 @@ public interface INonNegativeDiscreteDistribution : IDistribution<uint>;
     /// <summary>
     /// Continuous data distribution
     /// </summary>
-    public interface IContinuousDistribution : IDistribution<float>;
+    public interface IContinuousDistribution<out T> : IDistribution<T> where T : unmanaged, INumber<T>, IBinaryFloatingPointIeee754<T>;
 
     /// <summary>
     /// Indicates that the type has a size
@@ -636,6 +637,45 @@ public interface IFixedSizeSortedArray<V, W> : IHaveSize
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        void RemoveAt(byte index);
+        V RemoveAt(byte index);
+    }
+
+    public interface IGraphNode : IHaveSingleIndex
+    {
+        ReadOnlySpan<uint> NeighbourSpan { get; }
+        IEnumerable<uint> Neighbours { get; }
+    }
+
+    public interface IWeightedGraphNode<out T, W> : IGraphNode
+        where T: IHaveSingleIndex
+        where W : unmanaged, INumber<W>, IMinMaxValue<W>
+    {
+        public T Value { get; }
+
+        bool AddNeighbour(uint index, W weight);
+
+        IEnumerable<(uint Index, W Weight)> WeightedNeighbours { get; }
+    }
+
+    public interface ICalculateNodeWeights<out W>
+        where W : unmanaged, INumber<W>, IMinMaxValue<W>
+    {
+        W GetWeight(uint fromIndex, uint toIndex);
+    }
+
+    public interface IWeightedGraph<T, W> : IHaveSize
+        where T: IHaveSingleIndex
+        where W : unmanaged, INumber<W>, IMinMaxValue<W>
+    {
+        IWeightedGraphNode<T, W> Create(T value, bool addToGraph = true);
+
+        void Add(IWeightedGraphNode<T, W> node);
+
+        IWeightedGraphNode<T, W> Get(uint index);
+
+        RAT Search<RAT, CAT>(uint q, uint entryPoint, ICalculateNodeWeights<W> distanceCalculator)
+            where RAT : struct, IFixedSizeSortedArray<uint, W>
+            where CAT : struct, IFixedSizeSortedArray<uint, W>
+        ;
     }
 }
diff --git a/BrightData/LinearAlgebra/VectorIndexing/Helper/IndexedFixedSizeGraphNode.cs b/BrightData/LinearAlgebra/VectorIndexing/Helper/IndexedFixedSizeGraphNode.cs
index a1e8075f..065a5a22 100644
--- a/BrightData/LinearAlgebra/VectorIndexing/Helper/IndexedFixedSizeGraphNode.cs
+++ b/BrightData/LinearAlgebra/VectorIndexing/Helper/IndexedFixedSizeGraphNode.cs
@@ -1,9 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using BrightData.Types;
 
 namespace BrightData.LinearAlgebra.VectorIndexing.Helper
 {
diff --git a/BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArray.cs b/BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArrayTemplate.cs
similarity index 83%
rename from BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArray.cs
rename to BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArrayTemplate.cs
index 4fa415d1..0ec85f22 100644
--- a/BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArray.cs
+++ b/BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArrayTemplate.cs
@@ -3,10 +3,267 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Collections.Generic;
-using BrightData.Types.FixedSizeSortedArray;
+using BrightData.Types.Helper;
+using System.Linq;
 
 namespace BrightData.Types
 {
+    /// <summary>
+    /// Fixed size sorted array of values and weights (max 1 elements)
+    /// that is sorted in ascending order based on each weight
+    /// </summary>
+    /// <typeparam name="V">Type of value to store</typeparam>
+    /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
+    public record struct FixedSizeSortedAscending1Array<V, W>() : IFixedSizeSortedArray<V, W>
+        where V : IComparable<V>
+        where W : unmanaged, INumber<W>, IMinMaxValue<W>
+    {
+        /// <summary>
+        /// Max size of the array
+        /// </summary>
+        public const int MaxSize = 1;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
+
+        [InlineArray(MaxSize)]
+        internal struct ValueArray
+        {
+            public V _element0;
+        }
+        [InlineArray(MaxSize)]
+        internal struct WeightArray
+        {
+            public W _element0;
+        }
+        readonly ValueArray _values = new();
+        readonly WeightArray _weights = new();
+        byte _size = 0;
+
+        /// <summary>
+        /// Current number of elements
+        /// </summary>
+        public readonly byte Size => _size;
+
+        /// <summary>
+        /// Sorted list of values
+        /// </summary>
+        public readonly ReadOnlySpan<V> Values => MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
+
+        /// <summary>
+        /// Sorted list of weights
+        /// </summary>
+        public readonly ReadOnlySpan<W> Weights => MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
+
+        /// <summary>
+        /// The smallest weight
+        /// </summary>
+        public readonly W MinWeight => _size > 0 ? Weights[0] : W.MaxValue;
+
+        /// <summary>
+        /// The largest weight
+        /// </summary>
+        public readonly W MaxWeight => _size > 0 ? Weights[_size - 1] : W.MinValue;
+
+        /// <summary>
+        /// The value with the smallest weight
+        /// </summary>
+        public readonly V? MinValue => _size > 0 ? Values[0] : default;
+
+        /// <summary>
+        /// The value with the largest weight
+        /// </summary>
+        public readonly V? MaxValue => _size > 0 ? Values[_size - 1] : default;
+
+        /// <summary>
+        /// Returns a value and weight
+        /// </summary>
+        /// <param name="index">Index to return</param>
+        public readonly (V Value, W Weight) this[byte index]
+        {
+            get
+            {
+                if (index < Size)
+                    return (Values[index], Weights[index]);
+                throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        /// <summary>
+        /// Enumerates the values and weights
+        /// </summary>
+        public readonly IEnumerable<(V Value, W Weight)> Elements
+        {
+            get
+            {
+                for (byte i = 0; i < Size; i++)
+                    yield return this[i];
+            }
+        }
+
+        /// <summary>
+        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// </summary>
+        /// <param name="value">Value to add</param>
+        /// <param name="weight">Weight to add</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
+        /// <returns>True if the element was added</returns>
+        public bool TryAdd(V value, W weight, bool enforceUnique = true)
+        {
+            var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
+            var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
+        }
+
+        /// <summary>
+        /// Removes an element from the array
+        /// </summary>
+        /// <param name="index">Index of element to remove</param>
+        /// <exception cref="ArgumentOutOfRangeException"></exception>
+        public V RemoveAt(byte index)
+        {
+            if(index >= _size)
+                throw new ArgumentOutOfRangeException();
+            var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
+            var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
+            --_size;
+            return ret;
+        }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
+    }
+
+    /// <summary>
+    /// Fixed size sorted array of values and weights (max 1 elements)
+    /// that is sorted in descending order based on each weight
+    /// </summary>
+    /// <typeparam name="V">Type of value to store</typeparam>
+    /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
+    public record struct FixedSizeSortedDescending1Array<V, W>() : IFixedSizeSortedArray<V, W>
+        where V : IComparable<V>
+        where W : unmanaged, INumber<W>, IMinMaxValue<W>
+    {
+        /// <summary>
+        /// Max size of the array
+        /// </summary>
+        public const int MaxSize = 1;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
+
+        [InlineArray(MaxSize)]
+        internal struct ValueArray
+        {
+            public V _element0;
+        }
+        [InlineArray(MaxSize)]
+        internal struct WeightArray
+        {
+            public W _element0;
+        }
+        readonly ValueArray _values = new();
+        readonly WeightArray _weights = new();
+        byte _size = 0;
+
+        /// <summary>
+        /// Current number of elements
+        /// </summary>
+        public readonly byte Size => _size;
+
+        /// <summary>
+        /// Sorted list of values
+        /// </summary>
+        public readonly ReadOnlySpan<V> Values => MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
+
+        /// <summary>
+        /// Sorted list of weights
+        /// </summary>
+        public readonly ReadOnlySpan<W> Weights => MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
+
+        /// <summary>
+        /// The smallest weight
+        /// </summary>
+        public readonly W MinWeight => _size > 0 ? Weights[_size - 1] : W.MaxValue;
+
+        /// <summary>
+        /// The largest weight
+        /// </summary>
+        public readonly W MaxWeight => _size > 0 ? Weights[0] : W.MinValue;
+
+        /// <summary>
+        /// The value with the smallest weight
+        /// </summary>
+        public readonly V? MinValue => _size > 0 ? Values[_size - 1] : default;
+
+        /// <summary>
+        /// The value with the largest weight
+        /// </summary>
+        public readonly V? MaxValue => _size > 0 ? Values[0] : default;
+
+        /// <summary>
+        /// Returns a value and weight
+        /// </summary>
+        /// <param name="index">Index to return</param>
+        public readonly (V Value, W Weight) this[byte index]
+        {
+            get
+            {
+                if (index < Size)
+                    return (Values[index], Weights[index]);
+                throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        /// <summary>
+        /// Enumerates the values and weights
+        /// </summary>
+        public readonly IEnumerable<(V Value, W Weight)> Elements
+        {
+            get
+            {
+                for (byte i = 0; i < Size; i++)
+                    yield return this[i];
+            }
+        }
+
+        /// <summary>
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
+        /// </summary>
+        /// <param name="value">Value to add</param>
+        /// <param name="weight">Weight to add</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
+        /// <returns>True if the element was added</returns>
+        public bool TryAdd(V value, W weight, bool enforceUnique = true)
+        {
+            var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
+            var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
+        }
+
+        /// <summary>
+        /// Removes an element from the array
+        /// </summary>
+        /// <param name="index">Index of element to remove</param>
+        /// <exception cref="ArgumentOutOfRangeException"></exception>
+        public V RemoveAt(byte index)
+        {
+            if(index >= _size)
+                throw new ArgumentOutOfRangeException();
+            var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
+            var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
+            --_size;
+            return ret;
+        }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
+    }
+
     /// <summary>
     /// Fixed size sorted array of values and weights (max 2 elements)
     /// that is sorted in ascending order based on each weight
@@ -103,13 +360,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -117,15 +377,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -134,7 +398,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending2Array<V, W>()
+    public record struct FixedSizeSortedDescending2Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -142,6 +406,7 @@ public record struct FixedSizeSortedDescending2Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 2;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -219,17 +484,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -237,15 +505,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -344,13 +616,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -358,15 +633,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -375,7 +654,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending3Array<V, W>()
+    public record struct FixedSizeSortedDescending3Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -383,6 +662,7 @@ public record struct FixedSizeSortedDescending3Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 3;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -460,17 +740,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -478,15 +761,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -585,13 +872,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -599,15 +889,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -616,7 +910,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending4Array<V, W>()
+    public record struct FixedSizeSortedDescending4Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -624,6 +918,7 @@ public record struct FixedSizeSortedDescending4Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 4;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -701,17 +996,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -719,15 +1017,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -826,13 +1128,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -840,15 +1145,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -857,7 +1166,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending5Array<V, W>()
+    public record struct FixedSizeSortedDescending5Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -865,6 +1174,7 @@ public record struct FixedSizeSortedDescending5Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 5;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -942,17 +1252,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -960,15 +1273,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -1067,13 +1384,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -1081,15 +1401,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -1098,7 +1422,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending6Array<V, W>()
+    public record struct FixedSizeSortedDescending6Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -1106,6 +1430,7 @@ public record struct FixedSizeSortedDescending6Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 6;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -1183,17 +1508,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -1201,15 +1529,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -1308,13 +1640,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -1322,15 +1657,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -1339,7 +1678,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending7Array<V, W>()
+    public record struct FixedSizeSortedDescending7Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -1347,6 +1686,7 @@ public record struct FixedSizeSortedDescending7Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 7;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -1424,17 +1764,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -1442,15 +1785,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -1549,13 +1896,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -1563,15 +1913,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -1580,7 +1934,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending8Array<V, W>()
+    public record struct FixedSizeSortedDescending8Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -1588,6 +1942,7 @@ public record struct FixedSizeSortedDescending8Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 8;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -1665,17 +2020,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -1683,15 +2041,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -1790,13 +2152,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -1804,15 +2169,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -1821,7 +2190,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending9Array<V, W>()
+    public record struct FixedSizeSortedDescending9Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -1829,6 +2198,7 @@ public record struct FixedSizeSortedDescending9Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 9;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -1906,17 +2276,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -1924,15 +2297,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -2031,13 +2408,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -2045,15 +2425,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -2062,7 +2446,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending10Array<V, W>()
+    public record struct FixedSizeSortedDescending10Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -2070,6 +2454,7 @@ public record struct FixedSizeSortedDescending10Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 10;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -2147,17 +2532,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -2165,15 +2553,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -2272,13 +2664,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -2286,15 +2681,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -2303,7 +2702,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending11Array<V, W>()
+    public record struct FixedSizeSortedDescending11Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -2311,6 +2710,7 @@ public record struct FixedSizeSortedDescending11Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 11;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -2388,17 +2788,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -2406,15 +2809,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -2513,13 +2920,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -2527,15 +2937,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -2544,7 +2958,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending12Array<V, W>()
+    public record struct FixedSizeSortedDescending12Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -2552,6 +2966,7 @@ public record struct FixedSizeSortedDescending12Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 12;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -2629,17 +3044,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -2647,15 +3065,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -2754,13 +3176,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -2768,15 +3193,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -2785,7 +3214,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending13Array<V, W>()
+    public record struct FixedSizeSortedDescending13Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -2793,6 +3222,7 @@ public record struct FixedSizeSortedDescending13Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 13;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -2870,17 +3300,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -2888,15 +3321,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -2995,13 +3432,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -3009,15 +3449,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -3026,7 +3470,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending14Array<V, W>()
+    public record struct FixedSizeSortedDescending14Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -3034,6 +3478,7 @@ public record struct FixedSizeSortedDescending14Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 14;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -3111,17 +3556,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -3129,15 +3577,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -3236,13 +3688,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -3250,15 +3705,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -3267,7 +3726,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending15Array<V, W>()
+    public record struct FixedSizeSortedDescending15Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -3275,6 +3734,7 @@ public record struct FixedSizeSortedDescending15Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 15;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -3352,17 +3812,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -3370,15 +3833,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -3477,13 +3944,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -3491,15 +3961,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -3508,7 +3982,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending16Array<V, W>()
+    public record struct FixedSizeSortedDescending16Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -3516,6 +3990,7 @@ public record struct FixedSizeSortedDescending16Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 16;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -3593,17 +4068,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -3611,15 +4089,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -3718,13 +4200,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -3732,15 +4217,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -3749,7 +4238,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending17Array<V, W>()
+    public record struct FixedSizeSortedDescending17Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -3757,6 +4246,7 @@ public record struct FixedSizeSortedDescending17Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 17;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -3834,17 +4324,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -3852,15 +4345,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -3959,13 +4456,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -3973,15 +4473,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -3990,7 +4494,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending18Array<V, W>()
+    public record struct FixedSizeSortedDescending18Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -3998,6 +4502,7 @@ public record struct FixedSizeSortedDescending18Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 18;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -4075,17 +4580,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -4093,15 +4601,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -4200,13 +4712,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -4214,15 +4729,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -4231,7 +4750,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending19Array<V, W>()
+    public record struct FixedSizeSortedDescending19Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -4239,6 +4758,7 @@ public record struct FixedSizeSortedDescending19Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 19;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -4316,17 +4836,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -4334,15 +4857,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -4441,13 +4968,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -4455,15 +4985,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -4472,7 +5006,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending20Array<V, W>()
+    public record struct FixedSizeSortedDescending20Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -4480,6 +5014,7 @@ public record struct FixedSizeSortedDescending20Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 20;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -4557,17 +5092,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -4575,15 +5113,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -4682,13 +5224,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -4696,15 +5241,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -4713,7 +5262,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending21Array<V, W>()
+    public record struct FixedSizeSortedDescending21Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -4721,6 +5270,7 @@ public record struct FixedSizeSortedDescending21Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 21;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -4798,17 +5348,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -4816,15 +5369,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -4923,13 +5480,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -4937,15 +5497,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -4954,7 +5518,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending22Array<V, W>()
+    public record struct FixedSizeSortedDescending22Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -4962,6 +5526,7 @@ public record struct FixedSizeSortedDescending22Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 22;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -5039,17 +5604,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -5057,15 +5625,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -5164,13 +5736,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -5178,15 +5753,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -5195,7 +5774,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending23Array<V, W>()
+    public record struct FixedSizeSortedDescending23Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -5203,6 +5782,7 @@ public record struct FixedSizeSortedDescending23Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 23;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -5280,17 +5860,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -5298,15 +5881,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -5405,13 +5992,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -5419,15 +6009,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -5436,7 +6030,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending24Array<V, W>()
+    public record struct FixedSizeSortedDescending24Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -5444,6 +6038,7 @@ public record struct FixedSizeSortedDescending24Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 24;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -5521,17 +6116,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -5539,15 +6137,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -5646,13 +6248,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -5660,15 +6265,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -5677,7 +6286,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending25Array<V, W>()
+    public record struct FixedSizeSortedDescending25Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -5685,6 +6294,7 @@ public record struct FixedSizeSortedDescending25Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 25;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -5762,17 +6372,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -5780,15 +6393,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -5887,13 +6504,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -5901,15 +6521,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -5918,7 +6542,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending26Array<V, W>()
+    public record struct FixedSizeSortedDescending26Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -5926,6 +6550,7 @@ public record struct FixedSizeSortedDescending26Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 26;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -6003,17 +6628,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -6021,15 +6649,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -6128,13 +6760,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -6142,15 +6777,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -6159,7 +6798,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending27Array<V, W>()
+    public record struct FixedSizeSortedDescending27Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -6167,6 +6806,7 @@ public record struct FixedSizeSortedDescending27Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 27;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -6244,17 +6884,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -6262,15 +6905,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -6369,13 +7016,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -6383,15 +7033,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -6400,7 +7054,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending28Array<V, W>()
+    public record struct FixedSizeSortedDescending28Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -6408,6 +7062,7 @@ public record struct FixedSizeSortedDescending28Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 28;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -6485,17 +7140,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -6503,15 +7161,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -6610,13 +7272,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -6624,15 +7289,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -6641,7 +7310,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending29Array<V, W>()
+    public record struct FixedSizeSortedDescending29Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -6649,6 +7318,7 @@ public record struct FixedSizeSortedDescending29Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 29;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -6726,17 +7396,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -6744,15 +7417,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -6851,13 +7528,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -6865,15 +7545,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -6882,7 +7566,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending30Array<V, W>()
+    public record struct FixedSizeSortedDescending30Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -6890,6 +7574,7 @@ public record struct FixedSizeSortedDescending30Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 30;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -6967,17 +7652,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -6985,15 +7673,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -7092,13 +7784,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -7106,15 +7801,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -7123,7 +7822,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending31Array<V, W>()
+    public record struct FixedSizeSortedDescending31Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -7131,6 +7830,7 @@ public record struct FixedSizeSortedDescending31Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 31;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -7208,17 +7908,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -7226,15 +7929,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -7333,13 +8040,16 @@ public readonly (V Value, W Weight) this[byte index]
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -7347,15 +8057,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -7364,7 +8078,7 @@ public void RemoveAt(byte index)
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending32Array<V, W>()
+    public record struct FixedSizeSortedDescending32Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -7372,6 +8086,7 @@ public record struct FixedSizeSortedDescending32Array<V, W>()
         /// Max size of the array
         /// </summary>
         public const int MaxSize = 32;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -7449,17 +8164,20 @@ public readonly (V Value, W Weight) this[byte index]
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -7467,15 +8185,19 @@ public bool TryAdd(V value, W weight, bool enforceUnique = true)
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
 }
\ No newline at end of file
diff --git a/BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArray.tt b/BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArrayTemplate.tt
similarity index 85%
rename from BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArray.tt
rename to BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArrayTemplate.tt
index 49e9c088..88d1deb8 100644
--- a/BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArray.tt
+++ b/BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArrayTemplate.tt
@@ -9,11 +9,12 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Collections.Generic;
-using BrightData.Types.FixedSizeSortedArray;
+using BrightData.Types.Helper;
+using System.Linq;
 
 namespace BrightData.Types
 {
-<# for(var i = 2; i <= 32; i++) { #>
+<# for(var i = 1; i <= 32; i++) { #>
     /// <summary>
     /// Fixed size sorted array of values and weights (max <#= i #> elements)
     /// that is sorted in ascending order based on each weight
@@ -110,13 +111,16 @@ namespace BrightData.Types
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoAscending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoAscending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -124,15 +128,19 @@ namespace BrightData.Types
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
     /// <summary>
@@ -141,7 +149,7 @@ namespace BrightData.Types
     /// </summary>
     /// <typeparam name="V">Type of value to store</typeparam>
     /// <typeparam name="W">Type of weight that will be used to sort</typeparam>
-    public record struct FixedSizeSortedDescending<#= i #>Array<V, W>()
+    public record struct FixedSizeSortedDescending<#= i #>Array<V, W>() : IFixedSizeSortedArray<V, W>
         where V : IComparable<V>
         where W : unmanaged, INumber<W>, IMinMaxValue<W>
     {
@@ -149,6 +157,7 @@ namespace BrightData.Types
         /// Max size of the array
         /// </summary>
         public const int MaxSize = <#= i #>;
+        byte IFixedSizeSortedArray<V, W>.MaxSize => MaxSize;
 
         [InlineArray(MaxSize)]
         internal struct ValueArray
@@ -226,17 +235,20 @@ namespace BrightData.Types
         }
 
         /// <summary>
-        /// Tries to add a new element - will succeed if there aren't already max elements with a smaller weight
+        /// Tries to add a new element - will succeed if there aren't already max elements with a higher weight
         /// </summary>
         /// <param name="value">Value to add</param>
         /// <param name="weight">Weight to add</param>
-        /// <param name="enforceUnique">True if values should be unique - will return false if the value already exists</param>
+        /// <param name="enforceUnique">True if elements should be unique - will return false if the value and weight already exists</param>
         /// <returns>True if the element was added</returns>
         public bool TryAdd(V value, W weight, bool enforceUnique = true)
         {
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), MaxSize);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), MaxSize);
-            return FixedSizeSortedArrayHelper.InsertIntoDescending(enforceUnique, ref _size, MaxSize, value, weight, values, weights);
+            var ret = SortedArrayHelper.InsertIntoDescending(enforceUnique, MaxSize, value, weight, values, weights);
+            if(ret && _size < MaxSize)
+                ++_size;
+            return ret;
         }
 
         /// <summary>
@@ -244,15 +256,19 @@ namespace BrightData.Types
         /// </summary>
         /// <param name="index">Index of element to remove</param>
         /// <exception cref="ArgumentOutOfRangeException"></exception>
-        public void RemoveAt(byte index)
+        public V RemoveAt(byte index)
         {
             if(index >= _size)
                 throw new ArgumentOutOfRangeException();
             var values = MemoryMarshal.CreateSpan(ref Unsafe.As<ValueArray, V>(ref Unsafe.AsRef(in _values)), _size);
             var weights = MemoryMarshal.CreateSpan(ref Unsafe.As<WeightArray, W>(ref Unsafe.AsRef(in _weights)), _size);
-            FixedSizeSortedArrayHelper.RemoveAt(index, values, weights);
+            var ret = values[index];
+            SortedArrayHelper.RemoveAt(index, values, weights);
             --_size;
+            return ret;
         }
+
+        public override string ToString() => string.Join(", ", Elements.Select(x => $"{x.Value}|{x.Weight}"));
     }
 
 <# } #>
diff --git a/BrightData/Types/Graph/FixedSizeWeightedGraph.cs b/BrightData/Types/Graph/FixedSizeWeightedGraph.cs
new file mode 100644
index 00000000..d7e4ebec
--- /dev/null
+++ b/BrightData/Types/Graph/FixedSizeWeightedGraph.cs
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BrightData.Types.Graph
+{
+    /// <summary>
+    /// A fixed size graph weighted graph
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="W"></typeparam>
+    /// <typeparam name="AT"></typeparam>
+    public class FixedSizeWeightedGraph<T, W, AT> : IWeightedGraph<T, W>
+        where T : IHaveSingleIndex
+        where W : unmanaged, INumber<W>, IMinMaxValue<W>
+        where AT : struct, IFixedSizeSortedArray<uint, W>
+
+    {
+        readonly Dictionary<uint, FixedSizeWeightedGraphNode<T, W, AT>> _nodes = [];
+
+        /// <inheritdoc />
+        public IWeightedGraphNode<T, W> Create(T value, bool addToGraph = true)
+        {
+            var ret = new FixedSizeWeightedGraphNode<T, W, AT>(value);
+            if(addToGraph)
+                _nodes.Add(value.Index, ret);
+            return ret;
+        }
+
+        /// <inheritdoc />
+        public void Add(IWeightedGraphNode<T, W> node)
+        {
+            if(node is FixedSizeWeightedGraphNode<T, W, AT> same)
+                _nodes.Add(same.Index, same);
+            else {
+                var ret = new FixedSizeWeightedGraphNode<T, W, AT>(node.Value);
+                foreach (var (neighbour, weight) in node.WeightedNeighbours)
+                    ret.AddNeighbour(neighbour, weight);
+                _nodes.Add(ret.Index, ret);
+            }
+        }
+
+        /// <inheritdoc />
+        public uint Size => (uint)_nodes.Count;
+
+        /// <inheritdoc />
+        public IWeightedGraphNode<T, W> Get(uint index) => _nodes[index];
+
+        /// <inheritdoc />
+        public RAT Search<RAT, CAT>(uint q, uint entryPoint, ICalculateNodeWeights<W> distanceCalculator)
+            where RAT : struct, IFixedSizeSortedArray<uint, W>
+            where CAT : struct, IFixedSizeSortedArray<uint, W>
+        {
+            var visited = new HashSet<uint> { entryPoint };
+            var candidates = new CAT();
+            var distanceEQ = distanceCalculator.GetWeight(q, entryPoint);
+            candidates.TryAdd(entryPoint, distanceEQ);
+            var ret = new RAT();
+            ret.TryAdd(entryPoint, distanceEQ);
+
+            while (candidates.Size > 0) {
+                var c = candidates.RemoveAt(0);
+                var f = ret.MaxValue;
+                if (distanceCalculator.GetWeight(c, q) > distanceCalculator.GetWeight(f, q))
+                    break;
+
+                foreach (var neighbour in _nodes[c].NeighbourSpan) {
+                    if(!visited.Add(neighbour))
+                        continue;
+
+                    f = ret.MaxValue;
+                    if ((distanceEQ = distanceCalculator.GetWeight(neighbour, q)) < distanceCalculator.GetWeight(f, q)) {
+                        candidates.TryAdd(neighbour, distanceEQ);
+                        ret.TryAdd(neighbour, distanceEQ);
+                    }
+                }
+            }
+            return ret;
+        }
+    }
+}
diff --git a/BrightData/Types/Graph/FixedSizeWeightedGraphNode.cs b/BrightData/Types/Graph/FixedSizeWeightedGraphNode.cs
new file mode 100644
index 00000000..85cbd546
--- /dev/null
+++ b/BrightData/Types/Graph/FixedSizeWeightedGraphNode.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BrightData.Types.Graph
+{
+    /// <summary>
+    /// A graph node with a (fixed size) maximum number of neighbours
+    /// </summary>
+    public record FixedSizeWeightedGraphNode<T, W, AT>(T Value) : IWeightedGraphNode<T, W>, IComparable<FixedSizeWeightedGraphNode<T, W, AT>>
+        where T : IHaveSingleIndex
+        where W : unmanaged, INumber<W>, IMinMaxValue<W>
+        where AT : struct, IFixedSizeSortedArray<uint, W>
+    {
+        AT _neighbours = new();
+
+        /// <inheritdoc />
+        public uint Index => Value.Index;
+
+        /// <summary>
+        /// Tries to add a new neighbour
+        /// </summary>
+        /// <param name="index">Index of neighbour</param>
+        /// <param name="weight">Neighbour weight</param>
+        public bool AddNeighbour(uint index, W weight)
+        {
+            if(index != Value.Index)
+                return _neighbours.TryAdd(index, weight);
+            return false;
+        }
+
+        /// <inheritdoc />
+        public IEnumerable<(uint Index, W Weight)> WeightedNeighbours => _neighbours.Elements;
+
+        /// <summary>
+        /// Ordered span of neighbours by weight
+        /// </summary>
+        public ReadOnlySpan<uint> NeighbourSpan => _neighbours.Values;
+
+        /// <summary>
+        /// Enumerates the neighbours by weight
+        /// </summary>
+        public IEnumerable<uint> Neighbours
+        {
+            get
+            {
+                for (byte i = 0, len = _neighbours.Size; i < len; i++) {
+                    yield return _neighbours.Values[i];
+                }
+            }
+        }
+
+        /// <inheritdoc />
+        public int CompareTo(FixedSizeWeightedGraphNode<T, W, AT>? other) => Value.Index.CompareTo(other?.Value.Index);
+
+        /// <inheritdoc />
+        public override string ToString() => $"{Value}: {_neighbours}";
+
+        
+    }
+}
diff --git a/BrightData/Types/Graph/GraphIndex.cs b/BrightData/Types/Graph/GraphIndex.cs
new file mode 100644
index 00000000..ed45a32b
--- /dev/null
+++ b/BrightData/Types/Graph/GraphIndex.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BrightData.Types.Graph
+{
+    /// <summary>
+    /// Index only graph node value
+    /// </summary>
+    /// <param name="Index"></param>
+    public readonly record struct GraphNodeIndex(uint Index) : IHaveSingleIndex, IComparable<GraphNodeIndex>
+    {
+        /// <inheritdoc />
+        public int CompareTo(GraphNodeIndex other) => Index.CompareTo(other.Index);
+
+        /// <inheritdoc />
+        public override string ToString() => Index.ToString();
+    }
+}
diff --git a/BrightData/Types/Graph/HierarchicalNavigationSmallWorldGraph.cs b/BrightData/Types/Graph/HierarchicalNavigationSmallWorldGraph.cs
new file mode 100644
index 00000000..4882fb85
--- /dev/null
+++ b/BrightData/Types/Graph/HierarchicalNavigationSmallWorldGraph.cs
@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+using BrightData.Distribution;
+
+namespace BrightData.Types.Graph
+{
+    public class HierarchicalNavigationSmallWorldGraph<T, W, AT, BLAT>(BrightDataContext context, int maxLayers)
+        where T : IHaveSingleIndex
+        where W : unmanaged, INumber<W>, IMinMaxValue<W>, IBinaryFloatingPointIeee754<W>
+        where AT : struct, IFixedSizeSortedArray<uint, W>
+        where BLAT : struct, IFixedSizeSortedArray<uint, W>
+    {
+        public record NodeIndex(T Value, uint LayerIndex) : IHaveSingleIndex
+        {
+            public uint Index => Value.Index;
+        }
+        readonly IContinuousDistribution<W> _distribution = context.CreateExponentialDistribution<W>(W.CreateSaturating(maxLayers));
+        readonly IWeightedGraph<NodeIndex, W>[] _layers = Enumerable.Range(0, maxLayers)
+            .Select(i => (IWeightedGraph<NodeIndex, W>)(i == 0 ? new FixedSizeWeightedGraph<NodeIndex, W, BLAT>() : new FixedSizeWeightedGraph<NodeIndex, W, AT>()))
+            .ToArray()
+        ;
+        IWeightedGraphNode<NodeIndex, W>? _entryPoint = null;
+
+        public void Add(IEnumerable<T> values, ICalculateNodeWeights<W> distanceCalculator)
+        {
+            foreach (var value in values) {
+                var entryPoint = _entryPoint;
+                var level = GetRandomLevel();
+
+                // zoom in
+                uint? entryPointLevel = null;
+                if (entryPoint is not null) {
+                    entryPointLevel = entryPoint.Value.LayerIndex;
+                    for (var i = entryPointLevel.Value; i > level; i--) {
+                        var layer = _layers[i];
+                        var w = layer.Search<FixedSizeSortedAscending1Array<uint, W>, AT>(value.Index, entryPoint.Index, distanceCalculator);
+                        entryPoint = layer.Get(w.MinValue);
+                    }
+                }
+
+                // add to levels
+                var from = Math.Min(level, entryPoint?.Value.LayerIndex ?? int.MaxValue);
+                for(var i = level; i > from; i--)
+                    _layers[i].Create(new NodeIndex(value, (uint)i));
+                for (var i = from; i >= 0; i--) {
+                    var layer = _layers[i];
+                    var newNode = layer.Create(new NodeIndex(value, (uint)i), false);
+                    if (entryPoint is not null) {
+                        var w = layer.Search<AT, BLAT>(value.Index, entryPoint.Index, distanceCalculator);
+                        foreach (var (ni, nw) in w.Elements) {
+                            layer.Get(ni).AddNeighbour(value.Index, nw);
+                            newNode.AddNeighbour(ni, nw);
+                        }
+                    }
+                    layer.Add(newNode);
+                }
+
+                if(!entryPointLevel.HasValue || level > entryPointLevel.Value)
+                    _entryPoint = _layers[level].Get(value.Index);
+            }
+        }
+
+        public AT KnnSearch(uint q, ICalculateNodeWeights<W> distanceCalculator)
+        {
+            var entryPoint = _entryPoint ?? throw new Exception("No nodes in graph");
+            for (var i = (int)entryPoint.Value.LayerIndex; i > 0; i--) {
+                var layer = _layers[i];
+                var w = layer.Search<AT, BLAT>(q, entryPoint.Index, distanceCalculator);
+                entryPoint = layer.Get(w.MinValue);
+            }
+            return _layers[0].Search<AT, BLAT>(q, entryPoint.Index, distanceCalculator);
+        }
+
+        public IEnumerable<uint> BreadthFirstSearch(uint index)
+        {
+            var queue = new Queue<uint>();
+            var visited = new HashSet<uint> { index};
+            var layer = _layers[0];
+            queue.Enqueue(index);
+
+            while (queue.Count > 0) {
+                var node = layer.Get(queue.Dequeue());
+                foreach (var neighbour in node.Neighbours) {
+                    if(!visited.Add(neighbour))
+                        continue;
+                    yield return neighbour;
+                }
+            }
+        }
+
+        int GetRandomLevel()
+        {
+            int ret;
+            do {
+                ret = int.CreateTruncating(_distribution.Sample());
+            } while (ret >= maxLayers);
+            return ret;
+        }
+    }
+}
diff --git a/BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArrayHelper.cs b/BrightData/Types/Helper/SortedArrayHelper.cs
similarity index 68%
rename from BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArrayHelper.cs
rename to BrightData/Types/Helper/SortedArrayHelper.cs
index 6c621d83..c1a5f4cb 100644
--- a/BrightData/Types/FixedSizeSortedArray/FixedSizeSortedArrayHelper.cs
+++ b/BrightData/Types/Helper/SortedArrayHelper.cs
@@ -1,18 +1,18 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Numerics;
-using System.Text;
-using System.Threading.Tasks;
 
-namespace BrightData.Types.FixedSizeSortedArray
+namespace BrightData.Types.Helper
 {
-    internal class FixedSizeSortedArrayHelper
+    /// <summary>
+    /// Fixed size array helper methods
+    /// </summary>
+    public class SortedArrayHelper
     {
-        public static bool InsertIntoAscending<V, W>(bool enforceUnique, ref byte size, byte maxSize, V value, W weight, Span<V> values, Span<W> weights)
+        internal static bool InsertIntoAscending<V, W>(bool enforceUnique, uint maxSize, V value, W weight, Span<V> values, Span<W> weights)
             where V : IComparable<V>
             where W : unmanaged, INumber<W>, IMinMaxValue<W>
         {
+            var size = values.Length;
             var isFull = size == maxSize;
 
             // check to see if it should be inserted
@@ -20,17 +20,20 @@ public static bool InsertIntoAscending<V, W>(bool enforceUnique, ref byte size,
                 return false;
 
             // use binary search to find the insertion position
-            int left = 0, 
-                right = size - 1, 
+            int left = 0,
+                right = size - 1,
                 insertPosition = size
             ;
-            while (left <= right) {
+            while (left <= right)
+            {
                 var mid = left + (right - left) / 2;
-                if (weights[mid] > weight) {
+                if (weights[mid] > weight)
+                {
                     insertPosition = mid;
                     right = mid - 1;
                 }
-                else {
+                else
+                {
                     // check for an existing weight/value
                     if (enforceUnique && weights[mid] == weight && values[mid].CompareTo(value) == 0)
                         return false;
@@ -38,9 +41,11 @@ public static bool InsertIntoAscending<V, W>(bool enforceUnique, ref byte size,
                 }
             }
 
-            if (enforceUnique) {
+            if (enforceUnique)
+            {
                 // check if the same element already exists in the left partition
-                for (var i = insertPosition - 1; i >= 0; i--) {
+                for (var i = insertPosition - 1; i >= 0; i--)
+                {
                     if (weights[i] < weight)
                         break;
                     if (values[i].CompareTo(value) == 0)
@@ -48,7 +53,8 @@ public static bool InsertIntoAscending<V, W>(bool enforceUnique, ref byte size,
                 }
 
                 // check if the same element already exists in the right partition
-                for (var i = insertPosition; i < size; i++) {
+                for (var i = insertPosition; i < size; i++)
+                {
                     if (weights[i] > weight)
                         break;
                     if (values[i].CompareTo(value) == 0)
@@ -56,14 +62,17 @@ public static bool InsertIntoAscending<V, W>(bool enforceUnique, ref byte size,
                 }
             }
 
-            if (insertPosition == size) {
+            if (insertPosition == size)
+            {
                 // there is no room left
                 if (isFull)
                     return false;
             }
-            else {
+            else
+            {
                 // shuffle to make room
-                for (var i = size - (isFull ? 2 : 1); i >= insertPosition; i--) {
+                for (var i = size - (isFull ? 2 : 1); i >= insertPosition; i--)
+                {
                     values[i + 1] = values[i];
                     weights[i + 1] = weights[i];
                 }
@@ -72,15 +81,14 @@ public static bool InsertIntoAscending<V, W>(bool enforceUnique, ref byte size,
             // insert the item
             values[insertPosition] = value;
             weights[insertPosition] = weight;
-            if (!isFull)
-                ++size;
             return true;
         }
 
-        public static bool InsertIntoDescending<V, W>(bool enforceUnique, ref byte size, byte maxSize, V value, W weight, Span<V> values, Span<W> weights)
+        internal static bool InsertIntoDescending<V, W>(bool enforceUnique, uint maxSize, V value, W weight, Span<V> values, Span<W> weights)
             where V : IComparable<V>
             where W : unmanaged, INumber<W>, IMinMaxValue<W>
         {
+            var size = values.Length;
             var isFull = size == maxSize;
 
             // check to see if it should be inserted
@@ -88,17 +96,20 @@ public static bool InsertIntoDescending<V, W>(bool enforceUnique, ref byte size,
                 return false;
 
             // use binary search to find the insertion position
-            int left = 0, 
-                right = size - 1, 
+            int left = 0,
+                right = size - 1,
                 insertPosition = size
             ;
-            while (left <= right) {
+            while (left <= right)
+            {
                 var mid = left + (right - left) / 2;
-                if (weights[mid] < weight) {
+                if (weights[mid] < weight)
+                {
                     insertPosition = mid;
                     right = mid - 1;
                 }
-                else {
+                else
+                {
                     // check for an existing weight/value
                     if (enforceUnique && weights[mid] == weight && values[mid].CompareTo(value) == 0)
                         return false;
@@ -106,9 +117,11 @@ public static bool InsertIntoDescending<V, W>(bool enforceUnique, ref byte size,
                 }
             }
 
-            if (enforceUnique) {
+            if (enforceUnique)
+            {
                 // check if the same element already exists in the left partition
-                for (var i = insertPosition - 1; i >= 0; i--) {
+                for (var i = insertPosition - 1; i >= 0; i--)
+                {
                     if (weights[i] > weight)
                         break;
                     if (values[i].CompareTo(value) == 0)
@@ -116,7 +129,8 @@ public static bool InsertIntoDescending<V, W>(bool enforceUnique, ref byte size,
                 }
 
                 // check if the same element already exists in the right partition
-                for (var i = insertPosition; i < size; i++) {
+                for (var i = insertPosition; i < size; i++)
+                {
                     if (weights[i] < weight)
                         break;
                     if (values[i].CompareTo(value) == 0)
@@ -124,14 +138,17 @@ public static bool InsertIntoDescending<V, W>(bool enforceUnique, ref byte size,
                 }
             }
 
-            if (insertPosition == size) {
+            if (insertPosition == size)
+            {
                 // there is no room left
                 if (isFull)
                     return false;
             }
-            else {
+            else
+            {
                 // shuffle to make room
-                for (var i = size - (isFull ? 2 : 1); i >= insertPosition; i--) {
+                for (var i = size - (isFull ? 2 : 1); i >= insertPosition; i--)
+                {
                     values[i + 1] = values[i];
                     weights[i + 1] = weights[i];
                 }
@@ -140,15 +157,13 @@ public static bool InsertIntoDescending<V, W>(bool enforceUnique, ref byte size,
             // insert the item
             values[insertPosition] = value;
             weights[insertPosition] = weight;
-            if (!isFull)
-                ++size;
             return true;
         }
 
-        public static void RemoveAt<V, W>(byte index, Span<V> values, Span<W> weights)
+        internal static void RemoveAt<V, W>(int index, Span<V> values, Span<W> weights)
         {
-            values[(index+1)..].CopyTo(values[index..]);
-            weights[(index+1)..].CopyTo(weights[index..]);
+            values[(index + 1)..].CopyTo(values[index..]);
+            weights[(index + 1)..].CopyTo(weights[index..]);
         }
     }
 }
diff --git a/BrightData/Types/SortedArray.cs b/BrightData/Types/SortedArray.cs
new file mode 100644
index 00000000..6b402458
--- /dev/null
+++ b/BrightData/Types/SortedArray.cs
@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using BrightData.Types.Helper;
+
+namespace BrightData.Types
+{
+    public class SortedArray<V, W>(int? capacity = null, bool isAscending = true) : IHaveSize
+        where V : IComparable<V>
+        where W : unmanaged, INumber<W>, IMinMaxValue<W>
+    {
+        readonly List<V> _values = capacity.HasValue ? new(capacity.Value) : new();
+        readonly List<W> _weights = capacity.HasValue ? new(capacity.Value) : new();
+
+        public Span<V> Values => CollectionsMarshal.AsSpan(_values);
+        public Span<W> Weights => CollectionsMarshal.AsSpan(_weights);
+        public uint Size => (uint)Values.Length;
+
+        public bool Add(in V item, W weight)
+        {
+            _values.Add(item);
+            _weights.Add(weight);
+            return isAscending
+                ? SortedArrayHelper.InsertIntoAscending(false, uint.MaxValue, item, weight, Values, Weights)
+                : SortedArrayHelper.InsertIntoDescending(false, uint.MaxValue, item, weight, Values, Weights)
+            ;
+        }
+
+        public void RemoveAt(uint index)
+        {
+            _values.RemoveAt((int)index);
+            _weights.RemoveAt((int)index);
+        }
+
+        public bool TryGet(W weight, [NotNullWhen(true)]out V? value)
+        {
+            var index = Weights.BinarySearch(weight);
+            if (index >= 0) {
+                value = _values[index];
+                return true;
+            }
+            value = default;
+            return false;
+        }
+    }
+}
diff --git a/BrightWire/ExecutionGraph/WeightInitialisation/Gaussian.cs b/BrightWire/ExecutionGraph/WeightInitialisation/Gaussian.cs
index f37311f6..ef5b8d1e 100644
--- a/BrightWire/ExecutionGraph/WeightInitialisation/Gaussian.cs
+++ b/BrightWire/ExecutionGraph/WeightInitialisation/Gaussian.cs
@@ -9,7 +9,7 @@ namespace BrightWire.ExecutionGraph.WeightInitialisation
     /// </summary>
     internal class Gaussian : IWeightInitialisation
     {
-        readonly IContinuousDistribution _distribution;
+        readonly IContinuousDistribution<float> _distribution;
         readonly GaussianVarianceCalibration _varianceCalibration;
         readonly GaussianVarianceCount _varianceCount;
         readonly LinearAlgebraProvider<float> _lap;
@@ -26,7 +26,7 @@ public Gaussian(
             _zeroBias = zeroInitialBias;
             _varianceCalibration = varianceCalibration;
             _varianceCount = varianceCount;
-            _distribution = _lap.Context.CreateNormalDistribution(0, stdDev);
+            _distribution = _lap.Context.CreateNormalDistribution<float>(0, stdDev);
         }
 
         float GetBias()
diff --git a/BrightWire/ExecutionGraph/WeightInitialisation/Xavier.cs b/BrightWire/ExecutionGraph/WeightInitialisation/Xavier.cs
index f00b5c27..349f5905 100644
--- a/BrightWire/ExecutionGraph/WeightInitialisation/Xavier.cs
+++ b/BrightWire/ExecutionGraph/WeightInitialisation/Xavier.cs
@@ -12,7 +12,7 @@ namespace BrightWire.ExecutionGraph.WeightInitialisation
     internal class Xavier(LinearAlgebraProvider<float> lap, float parameter = 6) : IWeightInitialisation
     {
         readonly float _parameter = MathF.Sqrt(parameter);
-        readonly Dictionary<(uint, uint), IContinuousDistribution> _distributionTable = new();
+        readonly Dictionary<(uint, uint), IContinuousDistribution<float>> _distributionTable = [];
 
         public IVector<float> CreateBias(uint size)
         {
@@ -29,7 +29,7 @@ public float GetWeight(uint inputSize, uint outputSize)
             var key = (inputSize, outputSize);
             if (!_distributionTable.TryGetValue(key, out var distribution)) {
                 var stdDev = _parameter / (inputSize + outputSize);
-                _distributionTable.Add(key, distribution = lap.Context.CreateContinuousDistribution(0, stdDev));
+                _distributionTable.Add(key, distribution = lap.Context.CreateContinuousDistribution<float>(0, stdDev));
             }
             return distribution.Sample();
         }