Merge branch 'master' of https://github.com/Open-NET-Libraries/Open.Collections

Author: electricessence

source/Extensions.Subsets.cs

@@ -81,15 +81,15 @@ public static IEnumerable<T[]> Subsets<T>(this IReadOnlyList<T> source, int coun
 		/// <param name="source">The source list to derive from.</param>
 		/// <param name="count">The maximum number of items in the result sets.</param>
 		/// <returns>An enumerable containing the resultant subsets as an buffer array.</returns>
-		public static IEnumerable<T[]> SubsetsBuffered<T>(this IReadOnlyList<T> source, int count)
+		public static IEnumerable<ReadOnlyMemory<T>> SubsetsBuffered<T>(this IReadOnlyList<T> source, int count)
 		{
 			var pool = ArrayPool<T>.Shared;
 			var buffer = pool.Rent(count);
-
+			var readBuffer = new ReadOnlyMemory<T>(buffer, 0, count);
 			try
 			{
-				foreach (var subset in Subsets(source, count, buffer))
-					yield return subset;
+				foreach (var _ in Subsets(source, count, buffer))
+					yield return readBuffer;
 			}
 			finally
 			{
@@ -108,7 +108,7 @@ public static IEnumerable<T[]> SubsetsBuffered<T>(this IReadOnlyList<T> source,
 		public static IEnumerable<T[]> Subsets<T>(this IReadOnlyList<T> source, int count)
 		{
 			foreach (var subset in SubsetsBuffered(source, count))
-				yield return subset.AsCopy(count);
+				yield return subset.ToArray();
 		}
 
 	}

source/Extensions.SubsetsProgressive.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+
+namespace Open.Collections
+{
+	public static partial class Extensions
+	{
+		/// <summary>
+		/// Progressively enumerates the possible (ordered) subsets of the list, limited by the provided count.
+		/// The buffer is filled with the values and returned as the yielded value.
+		/// Note: Works especially well when the source is a LazyList.
+		/// </summary>
+		/// <param name="source">The source list to derive from.</param>
+		/// <param name="count">The maximum number of items in the result sets.</param>
+		/// <param name="buffer">
+		/// A buffer to use instead of returning new arrays for each iteration.
+		/// It must be at least the length of the count.
+		/// </param>
+		/// <returns>An enumerable containing the resultant subsets.</returns>
+		public static IEnumerable<T[]> SubsetsProgressive<T>(this IReadOnlyList<T> source, int count, T[] buffer)
+		{
+			if (count < 1)
+				throw new ArgumentOutOfRangeException(nameof(count), count, "Must greater than zero.");
+			if (buffer is null)
+				throw new ArgumentNullException(nameof(buffer));
+			if (buffer.Length < count)
+				throw new ArgumentOutOfRangeException(nameof(buffer), buffer, "Length must be greater than or equal to the provided count.");
+
+			if (count == 1)
+			{
+				foreach (var e in source)
+				{
+					buffer[0] = e;
+					yield return buffer;
+				}
+				yield break;
+			}
+
+			var pool = ArrayPool<int>.Shared;
+			var indices = pool.Rent(count);
+			try
+			{
+				using var e = source.GetEnumerator();
+
+				// Setup the first result and make sure there's enough for the count.
+				var n = 0;
+				for (; n < count; ++n)
+				{
+					if (!e.MoveNext()) throw new ArgumentOutOfRangeException(nameof(count), count, "Is greater than the length of the source.");
+					buffer[n] = e.Current;
+					indices[n] = n;
+				}
+
+				// First result.
+				yield return buffer;
+
+				if (!e.MoveNext()) yield break; // Only one set.
+
+				var lastSlot = count - 1;
+
+				// Second result.
+				buffer[lastSlot] = e.Current;
+				yield return buffer;
+				indices[lastSlot] = n;
+
+				var nextToLastSlot = lastSlot - 1;
+
+			loop:
+				var prevIndex = n;
+				var pos = nextToLastSlot;
+
+				while (pos >= 0)
+				{
+					var firstRun = true;
+					var index = indices[pos];
+					while (index + 1 < prevIndex)
+					{
+						// Subsequent results.
+						buffer[pos] = source[++index];
+						indices[pos] = index;
+						if (firstRun)
+						{
+							while (pos < nextToLastSlot && index + 1 < prevIndex)
+							{
+								buffer[++pos] = source[++index];
+								indices[pos] = index;
+							}
+							prevIndex = indices[pos + 1];
+							firstRun = false;
+						}
+						yield return buffer;
+					}
+					--pos;
+					prevIndex = index;
+
+
+				}
+
+				if (!e.MoveNext()) yield break;
+
+				// Update the last one.
+				buffer[lastSlot] = e.Current;
+				for (var i = 0; i < lastSlot; ++i)
+				{
+					buffer[i] = source[i];
+					indices[i] = i;
+				}
+				yield return buffer;
+				indices[lastSlot] = ++n;
+
+				goto loop;
+			}
+			finally
+			{
+				pool.Return(indices);
+			}
+		}
+
+		/// <summary>
+		/// Enumerates the possible (ordered) subsets of the list, limited by the provided count.
+		/// The yielded results are a buffer (array) that is at least the length of the provided count.
+		/// NOTE: Do not retain the result array as it is returned to an array pool when complete.
+		/// </summary>
+		/// <param name="source">The source list to derive from.</param>
+		/// <param name="count">The maximum number of items in the result sets.</param>
+		/// <returns>An enumerable containing the resultant subsets as an buffer array.</returns>
+		public static IEnumerable<ReadOnlyMemory<T>> SubsetsProgressiveBuffered<T>(this IReadOnlyList<T> source, int count)
+		{
+			var pool = ArrayPool<T>.Shared;
+			var buffer = pool.Rent(count);
+			var readBuffer = new ReadOnlyMemory<T>(buffer, 0, count);
+			try
+			{
+				foreach (var _ in SubsetsProgressive(source, count, buffer))
+					yield return readBuffer;
+			}
+			finally
+			{
+				pool.Return(buffer, true);
+			}
+		}
+
+
+		/// <summary>
+		/// Enumerates the possible (ordered) subsets of the list, limited by the provided count.
+		/// A new array is created for each subset.
+		/// </summary>
+		/// <param name="source">The source list to derive from.</param>
+		/// <param name="count">The maximum number of items in the result sets.</param>
+		/// <returns>An enumerable containing the resultant subsets.</returns>
+		public static IEnumerable<T[]> SubsetsProgressive<T>(this IReadOnlyList<T> source, int count)
+		{
+			foreach (var subset in SubsetsProgressiveBuffered(source, count))
+				yield return subset.ToArray();
+		}
+
+	}
+}

testing/Open.Collections.Tests/SubsetTests.cs

@@ -10,6 +10,7 @@ public class SubsetTests
 		static ImmutableArray<char> Set2 = ImmutableArray.Create('A', 'C', 'E');
 		static ImmutableArray<char> Set3 = ImmutableArray.Create('A', 'B', 'C', 'D');
 		static ImmutableArray<int> Set4 = Enumerable.Range(1, 5).ToImmutableArray();
+		static ImmutableArray<int> Set5 = Enumerable.Range(1, 11).ToImmutableArray();
 
 		[Fact]
 		public void TestSubset1_2()
@@ -21,6 +22,9 @@ public void TestSubset1_2()
 			};
 			var actual = Set1.Subsets(2).ToArray();
 			Assert.Equal(expected, actual);
+
+			var progressive = Set1.SubsetsProgressive(2).ToArray();
+			Assert.Equal(expected, progressive);
 		}
 
 		[Fact]
@@ -33,6 +37,9 @@ public void TestSubset2_2()
 			};
 			var actual = Set2.Subsets(2).ToArray();
 			Assert.Equal(expected, actual);
+
+			var progressive = Set2.SubsetsProgressive(2).ToArray();
+			Assert.Equal(expected, progressive);
 		}
 
 		[Fact]
@@ -41,13 +48,15 @@ public void TestSubset3_2()
 			var expected = new char[][] {
 				new char[] { 'A', 'B' },
 				new char[] { 'A', 'C' },
-				new char[] { 'A', 'D' },
 				new char[] { 'B', 'C' },
+				new char[] { 'A', 'D' },
 				new char[] { 'B', 'D' },
 				new char[] { 'C', 'D' },
 			};
-			var actual = Set3.Subsets(2).ToArray();
-			Assert.Equal(expected, actual);
+			Assert.Equal(expected.Length, Set3.Subsets(2).Count());
+
+			var progressive = Set3.SubsetsProgressive(2).ToArray();
+			Assert.Equal(expected, progressive);
 		}
 
 		[Fact]
@@ -61,10 +70,13 @@ public void TestSubset3_3()
 			};
 			var actual = Set3.Subsets(3).ToArray();
 			Assert.Equal(expected, actual);
+
+			var progressive = Set3.SubsetsProgressive(3).ToArray();
+			Assert.Equal(expected, progressive);
 		}
 
 		[Fact]
-		public void TestSubset3_4()
+		public void TestSubset4_4()
 		{
 			var expected = new int[][] {
 				new int[] { 1, 2, 3, 4 },
@@ -75,6 +87,35 @@ public void TestSubset3_4()
 			};
 			var actual = Set4.Subsets(4).ToArray();
 			Assert.Equal(expected, actual);
+
+			var progressive = Set4.SubsetsProgressive(4).ToArray();
+			Assert.Equal(expected, progressive);
+		}
+
+		[Fact]
+		public void TestSubset4_3()
+		{
+			var expected = new int[][] {
+				new int[] { 1, 2, 3 },
+				new int[] { 1, 2, 4 },
+				new int[] { 1, 3, 4 },
+				new int[] { 2, 3, 4 },
+				new int[] { 1, 2, 5 },
+				new int[] { 1, 3, 5 },
+				new int[] { 1, 4, 5 },
+				new int[] { 2, 3, 5 },
+				new int[] { 2, 4, 5 },
+				new int[] { 3, 4, 5 },
+			};
+			var actual = Set4.SubsetsProgressive(3).ToArray();
+			Assert.Equal(expected, actual);
+
+			var a2 = Set5.SubsetsProgressive(3);
+			var actual2 = a2.Take(10).ToArray();
+			Assert.Equal(expected, actual2);
+
+
+			Assert.Equal(Set5.Subsets(3).Count(), a2.Count());
 		}
 	}
 }