Added Subsets static for getting indexes instead of values.

Author: electricessence

.gitignore

@@ -274,3 +274,4 @@ __pycache__/
 benchmarking/.vscode/launch.json
 benchmarking/.vscode/tasks.json
 /source/nuget.config
+BenchmarkDotNet.Artifacts

benchmarking/Benchmarks/SubsetBenchmarks.cs

@@ -6,21 +6,21 @@ namespace Open.Collections.Benchmarks
 {
 	public class SubsetBenchmarks
 	{
-		readonly IEnumerable<int> FullSet = Enumerable.Range(0, 10);
+		readonly IEnumerable<int> FullSet = Enumerable.Range(0, 32);
 
 		[Benchmark]
 		public int Subset()
 		{
 			var buffer = new int[7];
-			var sum = FullSet.MemoizeUnsafe().Subsets(7, buffer).SelectMany(e => e).Sum();
+			var sum = FullSet.MemoizeUnsafe().Subsets(7, buffer).Count();
 			return sum;
 		}
 
 		[Benchmark]
 		public int SubsetProgressive()
 		{
 			var buffer = new int[7];
-			var sum = FullSet.MemoizeUnsafe().SubsetsProgressive(7, buffer).SelectMany(e => e).Sum();
+			var sum = FullSet.MemoizeUnsafe().SubsetsProgressive(7, buffer).Count();
 			return sum;
 		}
 	}

source/Extensions.SubsetsProgressive.cs

@@ -39,12 +39,10 @@ public static IEnumerable<T[]> SubsetsProgressive<T>(this IReadOnlyList<T> sourc
 
 				// Setup the first result and make sure there's enough for the count.
 				var n = 0;
-				var lowerSubset = new List<int>(count);
 				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;
-					lowerSubset.Add(n);
 				}
 
 				// First result.
@@ -53,14 +51,14 @@ public static IEnumerable<T[]> SubsetsProgressive<T>(this IReadOnlyList<T> sourc
 				while (e.MoveNext())
 				{
 					buffer[lastSlot] = e.Current;
-					foreach (var _ in lowerSubset.Subsets(lastSlot, indices))
+					foreach (var _ in Collections.Subsets.IndexesInternal(n, lastSlot, indices))
 					{
 						for(var i = 0; i<lastSlot; i++)
 							buffer[i] = source[indices[i]];
 
 						yield return buffer;
 					}
-					lowerSubset.Add(n++);
+					++n;
 				}
 			}
 			finally
@@ -91,7 +89,7 @@ public static IEnumerable<ReadOnlyMemory<T>> SubsetsProgressiveBuffered<T>(this
 
 		/// <summary>
 		/// Progressively enumerates the possible (ordered) subsets of the list, limited by the provided count.
-		/// In contrast to the .Subsets(count) extension, this will produce consistent results regardless of source set size.
+		/// In contrast to the .Subsets(count) extension, this will produce consistent results regardless of source set size but is not as fast.
 		/// Favorable for larger source sets that enumeration may cause evaluation.
 		/// </summary>
 		/// <param name="source">The source list to derive from.</param>

source/Extensions.cs

@@ -2,6 +2,7 @@
 using System.Buffers;
 using System.Collections;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Diagnostics.Contracts;
 using System.Dynamic;
 using System.Linq;
@@ -879,5 +880,35 @@ public static Span<T> CopyToSpan<T>(this IEnumerable<T> source, Span<T> target)
 			return target.Slice(0, count);
 		}
 
+		/// <summary>
+		/// Builds an immutable array using the contents of the span.
+		/// </summary>
+		public static ImmutableArray<T> ToImmutableArray<T>(this ReadOnlySpan<T> span)
+		{
+			var builder = ImmutableArray.CreateBuilder<T>(span.Length);
+			foreach (var e in span)
+				builder.Add(e);
+			return builder.MoveToImmutable();
+		}
+
+		/// <inheritdoc cref="ToImmutableArray{T}(ReadOnlySpan{T})"/>
+		public static ImmutableArray<T> ToImmutableArray<T>(this Span<T> span)
+		{
+			var builder = ImmutableArray.CreateBuilder<T>(span.Length);
+			foreach (var e in span)
+				builder.Add(e);
+			return builder.MoveToImmutable();
+		}
+
+		/// <summary>
+		/// Builds an immutable array using the contents of the memory.
+		/// </summary>
+		public static ImmutableArray<T> ToImmutableArray<T>(this ReadOnlyMemory<T> memory)
+			=> memory.Span.ToImmutableArray();
+
+		/// <inheritdoc cref="ToImmutableArray{T}(ReadOnlyMemory{T})"/>
+		public static ImmutableArray<T> ToImmutableArray<T>(this Memory<T> memory)
+			=> memory.Span.ToImmutableArray();
+
 	}
 }

source/Open.Collections.csproj

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

source/Subsets.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace Open.Collections
+{
+	public static class Subsets
+	{
+		internal static IEnumerable<int[]> IndexesInternal(int sourceLength, int subsetLength, int[] buffer)
+		{
+			if (subsetLength == 1)
+			{
+				for (var i = 0; i < sourceLength; ++i)
+				{
+					buffer[0] = i;
+					yield return buffer;
+				}
+				yield break;
+			}
+
+			var diff = sourceLength - subsetLength;
+
+			var pos = 0;
+			var index = 0;
+
+		loop:
+			while (pos < subsetLength)
+			{
+				buffer[pos] = index;
+				++pos;
+				++index;
+			}
+
+			yield return buffer;
+
+			do
+			{
+				if (pos == 0) yield break;
+				index = buffer[--pos] + 1;
+			}
+			while (index > diff + pos);
+
+			goto loop;
+		}
+
+		/// <inheritdoc cref="Indexes(int, int)"/>
+		/// <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>
+		public static IEnumerable<int[]> Indexes(int sourceLength, int subsetLength, int[] buffer)
+		{
+
+			if (subsetLength < 1)
+				throw new ArgumentOutOfRangeException(nameof(subsetLength), subsetLength, "Must greater than zero.");
+			if (subsetLength > sourceLength)
+				throw new ArgumentOutOfRangeException(nameof(subsetLength), subsetLength, "Must be less than or equal to the length of the source set.");
+			if (buffer is null)
+				throw new ArgumentNullException(nameof(buffer));
+			if (buffer.Length < subsetLength)
+				throw new ArgumentOutOfRangeException(nameof(buffer), buffer, "Length must be greater than or equal to the provided count.");
+
+			return IndexesInternal(sourceLength, subsetLength, buffer);
+		}
+
+		/// <inheritdoc cref="Indexes(int, int)"/>
+		/// <remarks>Values are yielded as read only memory buffer that should not be retained as its array is returned to pool afterwards.</remarks>
+		public static IEnumerable<ReadOnlyMemory<int>> IndexesBuffered(int sourceLength, int subsetLength)
+		{
+			var pool = ArrayPool<int>.Shared;
+			var buffer = pool.Rent(subsetLength);
+			var readBuffer = new ReadOnlyMemory<int>(buffer, 0, subsetLength);
+			try
+			{
+				foreach (var _ in Indexes(sourceLength, subsetLength, buffer))
+					yield return readBuffer;
+			}
+			finally
+			{
+				pool.Return(buffer, true);
+			}
+		}
+
+		/// <summary>
+		/// Enumerates all the possible subset indexes for a given source set length and subset length.
+		/// </summary>
+		/// <param name="sourceLength">The length of the source set.</param>
+		/// <param name="subsetLength">The size of the desired subsets.</param>s
+		public static IEnumerable<int[]> Indexes(int sourceLength, int subsetLength)
+		{
+			foreach (var i in IndexesBuffered(sourceLength, subsetLength))
+				yield return i.ToArray();
+		}
+
+		/// <inheritdoc cref="Indexes(int, int)"/>
+		public static IEnumerable<ImmutableArray<int>> IndexesImmutable(int sourceLength, int subsetLength)
+		{
+			foreach (var i in IndexesBuffered(sourceLength, subsetLength))
+				yield return i.ToImmutableArray();
+		}
+	}
+
+}