Merge pull request #906 from Silver-Fang/BigInteger

Combinatorics.GenerateVariation for large N

Author: cdrnet

src/Numerics.Tests/CombinatoricsTests/CombinatoricsGenerationTest.cs

@@ -0,0 +1,71 @@
+// <copyright file="CombinatoricsGenerationTest.cs" company="Math.NET">
+// Math.NET Numerics, part of the Math.NET Project
+// http://numerics.mathdotnet.com
+// http://github.com/mathnet/mathnet-numerics
+//
+// Copyright (c) 2009-2016 Math.NET
+//
+// Permission is hereby granted, free of charge, to any person
+// obtaining a copy of this software and associated documentation
+// files (the "Software"), to deal in the Software without
+// restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+// </copyright>
+
+using NUnit.Framework;
+using System.Numerics;
+namespace MathNet.Numerics.UnitTests.CombinatoricsTests
+{
+
+    /// <summary>
+    /// Test if combinatoric generation functions work correctly.
+    /// </summary>
+    [TestFixture]
+    public class CombinatoricsGenerationTest
+    {
+        private void CGBIV(BigInteger n,int k)
+        {
+            BigInteger[] selection = Combinatorics.GenerateVariation(n, k);
+            Assert.AreEqual(k, selection.Length);
+            for (int i = 0; i < k; i++)
+            {
+                Assert.GreaterOrEqual(selection[i], 0);
+                Assert.Less(selection[i], n);
+                System.Console.Write(selection[i] + " ");
+            }
+        }
+        static readonly BigInteger TestBI = new BigInteger(ulong.MaxValue) * 6;
+        /// <summary>
+        /// BigInteger isn't const so we can't simply set TestCase attributes. <br/>
+        /// You need to check if the generated variation is statistically likely to be correct. Auto assertion won't find such error.
+        /// </summary>
+        /// <param name="n">N parameter.</param>
+        /// <param name="k">K parameter.</param>
+        /// <param name="expected">Expected value.</param>
+        [Test]
+        public void CanGenerateBigIntegerVariations()
+        {
+            //Main case
+            CGBIV(TestBI, 6);
+            //Border cases
+            CGBIV(0, 0);
+            CGBIV(6, 0);
+            CGBIV(6, 6);
+        }
+    }
+}

src/Numerics/Combinatorics.cs

@@ -31,6 +31,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using MathNet.Numerics.Random;
+using System.Numerics;
 
 namespace MathNet.Numerics
 {
@@ -354,6 +355,50 @@ public static int[] GenerateVariation(int n, int k, System.Random randomSource =
             return selection;
         }
 
+        /// <summary>
+        /// Generate a random variation, without repetition, by randomly selecting k of n elements with order. This is an O(k) space-complexity implementation optimized for very large N.<br/>
+        /// The space complexity of Fisher-Yates Shuffling is O(n+k). When N is very large, the algorithm will be unexecutable in limited memory, and a more memory-efficient algorithm is needed.<br/>
+        /// You can explicitly cast N to <see cref="BigInteger"/> if N is out of range of <see cref="int"/> or memory, so that this special implementation is called. However, this implementation is slower than Fisher-Yates Shuffling: don't call it if time is more critical than space.<br/>
+        /// The K of type <see cref="BigInteger"/> seems impossible, because the returned array is of size K and must all be stored in memory.
+        /// </summary>
+        /// <param name="n">Number of elements in the set.</param>
+        /// <param name="k">Number of elements to choose from the set. Each element is chosen at most once.</param>
+        /// <param name="randomSource">The random number generator to use. Optional; the default random source will be used if null.</param>
+        /// <returns>An array of length <c>K</c> that contains the indices of the selections as integers of the interval <c>[0, N)</c>.</returns>
+        public static BigInteger[] GenerateVariation(BigInteger n, int k, System.Random randomSource = null)
+        {
+            if (n < 0) throw new ArgumentOutOfRangeException(nameof(n), "Value must not be negative (zero is ok).");
+            if (k < 0) throw new ArgumentOutOfRangeException(nameof(k), "Value must not be negative (zero is ok).");
+            if (k > n) throw new ArgumentOutOfRangeException(nameof(k), $"k must be smaller than or equal to n.");
+
+            var random = randomSource ?? SystemRandomSource.Default;
+            BigInteger[] selection = new BigInteger[k];
+            if (n == 0 || k == 0)
+                return selection;
+            selection[0] = random.NextBigIntegerSequence(0, n).First();
+            bool[] CompareCache;
+            bool KeepLooping;
+            BigInteger RandomNumber;
+            for (int a = 1; a < k; a++)
+            {
+                RandomNumber = random.NextBigIntegerSequence(0, n - a).First();
+                CompareCache = Enumerable.Repeat(true, a).ToArray();
+                do
+                {
+                    KeepLooping = false;
+                    for (int b = 0; b < a; ++b)
+                        if (CompareCache[b] && RandomNumber >= selection[b])
+                        {
+                            CompareCache[b] = false;
+                            KeepLooping = true;
+                            RandomNumber++;
+                        }
+                } while (KeepLooping);
+                selection[a] = RandomNumber;
+            }
+            return selection;
+        }
+
         /// <summary>
         /// Select a random variation, without repetition, from a data sequence by randomly selecting k elements in random order.
         /// Implemented using partial Fisher-Yates Shuffling.