Merge pull request #18 from Dowlatabadi/RandomDrawItems

Randomly Drawn x Items Method Added (woithout placement using Fisher-…

Author: jkonecki

src/RandomGen/Fluent/INumbers.cs

@@ -1,11 +1,13 @@
 using System;
+using System.Collections.Generic;
 
 namespace RandomGen.Fluent
 {
     public interface INumbers : IFluentInterface
     {
         Func<byte> Bytes(byte min = byte.MinValue, byte max = byte.MaxValue);
         Func<int> Integers(int min = 0, int max = 100);
+        Func<IEnumerable<int>> IntegersDrawNoPlacement(int min = 0, int max = 100, int take = 1);
         Func<uint> UnsignedIntegers(uint min = 0, uint max = 100);
         Func<long> Longs(long min = 0, long max = 100);
         IDouble Doubles();

src/RandomGen/Fluent/IRandom.cs

@@ -74,6 +74,14 @@ public interface IRandom : IFluentInterface
         /// <param name="weights">Optional weights affecting the likelihood of a value being chosen. Same length as Enum values</param>
         Func<T> Enum<T>(IEnumerable<double> weights = null) where T : struct, IConvertible;
 
+        /// <summary>
+        /// Returns a list of randomly drawn elements without placements
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="items"></param>
+        /// <param name="take">The numbers of desired drawn elements</param>
+        Func<IEnumerable<T>> ItemsNoPlacement<T>(IEnumerable<T> items, int take = 1);
+
         /// <summary>
         /// Generates random country names
         /// Based on System.Globalisation

src/RandomGen/NumbersLink.cs

@@ -35,6 +35,32 @@ public Func<int> Integers(int min = 0, int max = 100)
             return () => random.Next(min, max);
         }
 
+        public Func<IEnumerable<int>> IntegersDrawNoPlacement(int min = 0, int max = 100, int take = 1)
+        {
+            if (min >= max)
+                throw new ArgumentOutOfRangeException("min >= max");
+            if (take > (max - min))
+                throw new ArgumentOutOfRangeException("available < take");
+
+            var pool = Enumerable.Range(0, max - min).ToArray();
+            var result = new List<int>();
+            var random = this._genLink.CreateRandom();
+            
+            //Modern Fisher–Yates shuffle with O(n) complexity
+            for (int i = 0; i < take; i++)
+            {
+                var itemIndex = random.Next(min, max - i);
+                
+                // swap taken index and current last
+                var buffer = pool[itemIndex];
+                pool[itemIndex] = pool[max - i - 1];
+                pool[max - i - 1] = buffer;
+                result.Add(buffer + min);
+            }
+
+            return () => result;
+        }
+        
         public Func<uint> UnsignedIntegers(uint min = 0, uint max = 100)
         {
             if (min >= max)

src/RandomGen/RandomLink.cs

@@ -99,5 +99,13 @@ public Func<string> Countries()
 
             return this.Items(data);
         }
+
+        public Func<IEnumerable<T>> ItemsNoPlacement<T>(IEnumerable<T> items, int take = 1)
+        {
+            var indexes = this.Numbers.IntegersDrawNoPlacement(0, items.Count(), take)();
+            var result = indexes.Select(i => items.ElementAt(i));
+            
+            return () => result;
+        }
     }
 }

test/RandomGen.Tests/RandomTests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Text;
 using System.Threading;
@@ -219,6 +220,28 @@ public void RandomItems()
                 Console.WriteLine(item);
             }
         }
+        
+        [Fact]
+        public void RandomItemsNoPlacement()
+        {
+            var take = 1000000;
+            var random = new Random();
+            var input = Enumerable.Range(0, 10000000).ToList();
+            
+            var sw = Stopwatch.StartNew();
+            var fisherYatesShuffle = Gen.Random.ItemsNoPlacement(input, take)().ToList();
+            var fisherYatesTime = sw.Elapsed.TotalSeconds;
+            
+            sw.Restart();
+            var normal = input.OrderBy(x => random.NextDouble()).Take(take).ToList();
+            var normalTime = sw.Elapsed.TotalSeconds;
+
+            //check for non duplicate items
+            Assert.False(fisherYatesShuffle.GroupBy(x => x).Where(x => x.Count() > 1).Any());
+            Assert.False(normal.GroupBy(x => x).Where(x => x.Count() > 1).Any());
+            
+            Console.WriteLine($"For large lists Fisher Yates shuffle should outperform random shuffling: {fisherYatesTime}<{normalTime}");
+        }
 
         [Fact]
         public void ListLikelihoodWeightsWorks()