Added low memory static methods for PossibleAddends.

Author: electricessence

Open.Collections.Numeric.csproj

@@ -17,7 +17,7 @@
 		<PackageProjectUrl>https://github.com/Open-NET-Libraries/Open.Collections.Numeric/</PackageProjectUrl>
 		<RepositoryUrl>https://github.com/Open-NET-Libraries/Open.Collections.Numeric/</RepositoryUrl>
 		<RepositoryType>git</RepositoryType>
-		<Version>1.5.3</Version>
+		<Version>1.5.4</Version>
 		<PackageReleaseNotes></PackageReleaseNotes>
 		<PackageLicenseExpression>MIT</PackageLicenseExpression>
 		<PublishRepositoryUrl>true</PublishRepositoryUrl>

PossibleAddends.cs

@@ -1,8 +1,10 @@
 using Open.Disposable;
 using System;
+using System.Buffers;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Linq;
 
 namespace Open.Collections.Numeric
 {
@@ -44,16 +46,18 @@ public IEnumerable<IReadOnlyList<int>> GetUniqueAddends(int sum, int count)
 
 			{
 				int i = 2;
+				var c1 = count - 1;
+				var c2 = c1 - 1;
 				var builder = ImmutableArray.CreateBuilder<int>();
 
 				while (++i < sum)
 				{
 					var next = sum - i;
-					var addends = UniqueAddendsFor(i, count - 1);
+					var addends = UniqueAddendsFor(i, c1);
 					foreach (var a in addends)
 					{
 						builder.Capacity = count;
-						if (a[a.Count - 1] >= next) continue;
+						if (a[c2] >= next) continue;
 						builder.AddRange(a);
 						builder.Add(next);
 						yield return builder.MoveToImmutable();
@@ -73,5 +77,59 @@ protected override void OnDispose()
 			}
 			Cache.Clear();
 		}
+
+
+		public static IEnumerable<int[]> GetUniqueAddendsBuffered(int sum, int count)
+		{
+			if (count > int.MaxValue)
+				throw new ArgumentOutOfRangeException(nameof(count), count, "Cannot be greater than signed 32 bit integer maximum.");
+			if (count < 2 || sum < 3)
+				yield break;
+
+			var pool = ArrayPool<int>.Shared;
+			var result = pool.Rent(count);
+
+			try
+			{
+				if (count == 2)
+				{
+					int i = 0;
+				loop2:
+					i++;
+					if (i * 2 >= sum) yield break;
+					result[0] = i;
+					result[1] = sum - i;
+					yield return result;
+
+					goto loop2;
+				}
+
+				{
+					int i = 2;
+					var c1 = count - 1;
+					var c2 = c1 - 1;
+
+					while (++i < sum)
+					{
+						var next = sum - i;
+						var addends = GetUniqueAddendsBuffered(i, c1);
+						foreach (var a in addends)
+						{
+							if (a[c2] >= next) continue;
+							a.CopyTo(result, 0);
+							result[c1] = next;
+							yield return result;
+						}
+					}
+				}
+			}
+			finally
+			{
+				pool.Return(result);
+			}
+		}
+
+		public static IEnumerable<IEnumerable<int>> GetUniqueAddendsEnumerable(int sum, int count)
+			=> GetUniqueAddendsBuffered(sum, count).Select(a => a.Take(count));
 	}
 }