Generate: new variants with fast RandomUniform

src/Numerics/Generate.cs

@@ -511,61 +511,37 @@ namespace MathNet.Numerics
         }
 
         /// <summary>
-        /// Generate samples by sampling a function at samples from a probability distribution.
+        /// Create random samples.
-        /// </summary>
-        public static T[] RandomMap<T>(int length, IContinuousDistribution distribution, Func<double, T> map)
-        {
-            var data = new T[length];
-            for (int i = 0; i < data.Length; i++)
-            {
-                data[i] = map(distribution.Sample());
-            }
-            return data;
-        }
-
-        /// <summary>
-        /// Generate a sample sequence by sampling a function at samples from a probability distribution.
-        /// </summary>
-        public static IEnumerable<T> RandomMapSequence<T>(IContinuousDistribution distribution, Func<double, T> map)
-        {
-            return distribution.Samples().Select(map);
-        }
-
-        /// <summary>
-        /// Generate samples by sampling a function at sample pairs from a probability distribution.
         /// </summary>
-        public static T[] RandomMap2<T>(int length, IContinuousDistribution distribution, Func<double, double, T> map)
+        public static double[] Random(int length, IContinuousDistribution distribution)
         {
-            var data = new T[length];
+            return distribution.Samples().Take(length).ToArray();
-            for (int i = 0; i < data.Length; i++)
-            {
-                data[i] = map(distribution.Sample(), distribution.Sample());
-            }
-            return data;
         }
 
         /// <summary>
-        /// Generate a sample sequence by sampling a function at sample pairs from a probability distribution.
+        /// Create an infinite random sample sequence.
         /// </summary>
-        public static IEnumerable<T> RandomMap2Sequence<T>(IContinuousDistribution distribution, Func<double, double, T> map)
+        public static IEnumerable<double> Random(IContinuousDistribution distribution)
         {
-            return distribution.Samples().Zip(distribution.Samples(), map);
+            return distribution.Samples();
         }
 
         /// <summary>
-        /// Create random samples.
+        /// Create random samples, uniform between 0 and 1.
+        /// Faster than other methods but with reduced guarantees on randomness.
         /// </summary>
-        public static double[] Random(int length, IContinuousDistribution distribution)
+        public static double[] RandomUniform(int length)
         {
-            return distribution.Samples().Take(length).ToArray();
+            return SystemRandomSource.Doubles(length);
         }
 
         /// <summary>
-        /// Create an infinite random sample sequence.
+        /// Create an infinite random sample sequence, uniform between 0 and 1.
+        /// Faster than other methods but with reduced guarantees on randomness.
         /// </summary>
-        public static IEnumerable<double> Random(IContinuousDistribution distribution)
+        public static IEnumerable<double> RandomUniform()
         {
-            return distribution.Samples();
+            return SystemRandomSource.DoubleSequence();
         }
 
         /// <summary>
@@ -624,5 +600,106 @@ namespace MathNet.Numerics
         {
             return Stable.Samples(SystemRandomSource.Default, alpha, beta, scale, location);
         }
+
+        /// <summary>
+        /// Generate samples by sampling a function at samples from a probability distribution.
+        /// </summary>
+        public static T[] RandomMap<T>(int length, IContinuousDistribution distribution, Func<double, T> map)
+        {
+            var data = new T[length];
+            for (int i = 0; i < data.Length; i++)
+            {
+                data[i] = map(distribution.Sample());
+            }
+            return data;
+        }
+
+        /// <summary>
+        /// Generate a sample sequence by sampling a function at samples from a probability distribution.
+        /// </summary>
+        public static IEnumerable<T> RandomMapSequence<T>(IContinuousDistribution distribution, Func<double, T> map)
+        {
+            return distribution.Samples().Select(map);
+        }
+
+        /// <summary>
+        /// Generate samples by sampling a function at sample pairs from a probability distribution.
+        /// </summary>
+        public static T[] RandomMap2<T>(int length, IContinuousDistribution distribution, Func<double, double, T> map)
+        {
+            var data = new T[length];
+            for (int i = 0; i < data.Length; i++)
+            {
+                data[i] = map(distribution.Sample(), distribution.Sample());
+            }
+            return data;
+        }
+
+        /// <summary>
+        /// Generate a sample sequence by sampling a function at sample pairs from a probability distribution.
+        /// </summary>
+        public static IEnumerable<T> RandomMap2Sequence<T>(IContinuousDistribution distribution, Func<double, double, T> map)
+        {
+            return distribution.Samples().Zip(distribution.Samples(), map);
+        }
+
+        /// <summary>
+        /// Generate samples by sampling a function at samples from a probability distribution, uniform between 0 and 1.
+        /// Faster than other methods but with reduced guarantees on randomness.
+        /// </summary>
+        public static T[] RandomUniformMap<T>(int length, Func<double, T> map)
+        {
+            var samples = SystemRandomSource.Doubles(length);
+            var data = new T[length];
+            for (int i = 0; i < data.Length; i++)
+            {
+                data[i] = map(samples[i]);
+            }
+            return data;
+        }
+
+        /// <summary>
+        /// Generate a sample sequence by sampling a function at samples from a probability distribution, uniform between 0 and 1.
+        /// Faster than other methods but with reduced guarantees on randomness.
+        /// </summary>
+        public static IEnumerable<T> RandomUniformMapSequence<T>(Func<double, T> map)
+        {
+            return SystemRandomSource.DoubleSequence().Select(map);
+        }
+
+        /// <summary>
+        /// Generate samples by sampling a function at sample pairs from a probability distribution, uniform between 0 and 1.
+        /// Faster than other methods but with reduced guarantees on randomness.
+        /// </summary>
+        public static T[] RandomUniformMap2<T>(int length, Func<double, double, T> map)
+        {
+            var samples1 = SystemRandomSource.Doubles(length);
+            var samples2 = SystemRandomSource.Doubles(length);
+            var data = new T[length];
+            for (int i = 0; i < data.Length; i++)
+            {
+                data[i] = map(samples1[i], samples2[i]);
+            }
+            return data;
+        }
+
+        /// <summary>
+        /// Generate a sample sequence by sampling a function at sample pairs from a probability distribution, uniform between 0 and 1.
+        /// Faster than other methods but with reduced guarantees on randomness.
+        /// </summary>
+        public static IEnumerable<T> RandomUniformMap2Sequence<T>(Func<double, double, T> map)
+        {
+            var rnd1 = SystemRandomSource.Default;
+            for (int i = 0; i < 128; i++)
+            {
+                yield return map(rnd1.NextDouble(), rnd1.NextDouble());
+            }
+
+            var rnd2 = new System.Random(RandomSeed.Robust());
+            while (true)
+            {
+                yield return map(rnd2.NextDouble(), rnd2.NextDouble());
+            }
+        }
     }
 }