From 4f2560bb2266adbf1beb67cc40cc499d13de273c Mon Sep 17 00:00:00 2001 From: Christoph Ruegg Date: Mon, 30 Dec 2013 23:23:02 +0100 Subject: [PATCH] Generate: new variants with fast RandomUniform --- src/Numerics/Generate.cs | 153 +++++++++++++++++++++++++++++---------- 1 file changed, 115 insertions(+), 38 deletions(-) diff --git a/src/Numerics/Generate.cs b/src/Numerics/Generate.cs index b447e3ae..5a720bd2 100644 --- a/src/Numerics/Generate.cs +++ b/src/Numerics/Generate.cs @@ -511,61 +511,37 @@ namespace MathNet.Numerics } /// - /// Generate samples by sampling a function at samples from a probability distribution. - /// - public static T[] RandomMap(int length, IContinuousDistribution distribution, Func map) - { - var data = new T[length]; - for (int i = 0; i < data.Length; i++) - { - data[i] = map(distribution.Sample()); - } - return data; - } - - /// - /// Generate a sample sequence by sampling a function at samples from a probability distribution. - /// - public static IEnumerable RandomMapSequence(IContinuousDistribution distribution, Func map) - { - return distribution.Samples().Select(map); - } - - /// - /// Generate samples by sampling a function at sample pairs from a probability distribution. + /// Create random samples. /// - public static T[] RandomMap2(int length, IContinuousDistribution distribution, Func map) + public static double[] Random(int length, IContinuousDistribution distribution) { - var data = new T[length]; - for (int i = 0; i < data.Length; i++) - { - data[i] = map(distribution.Sample(), distribution.Sample()); - } - return data; + return distribution.Samples().Take(length).ToArray(); } /// - /// Generate a sample sequence by sampling a function at sample pairs from a probability distribution. + /// Create an infinite random sample sequence. /// - public static IEnumerable RandomMap2Sequence(IContinuousDistribution distribution, Func map) + public static IEnumerable Random(IContinuousDistribution distribution) { - return distribution.Samples().Zip(distribution.Samples(), map); + return distribution.Samples(); } /// - /// Create random samples. + /// Create random samples, uniform between 0 and 1. + /// Faster than other methods but with reduced guarantees on randomness. /// - public static double[] Random(int length, IContinuousDistribution distribution) + public static double[] RandomUniform(int length) { - return distribution.Samples().Take(length).ToArray(); + return SystemRandomSource.Doubles(length); } /// - /// 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. /// - public static IEnumerable Random(IContinuousDistribution distribution) + public static IEnumerable RandomUniform() { - return distribution.Samples(); + return SystemRandomSource.DoubleSequence(); } /// @@ -624,5 +600,106 @@ namespace MathNet.Numerics { return Stable.Samples(SystemRandomSource.Default, alpha, beta, scale, location); } + + /// + /// Generate samples by sampling a function at samples from a probability distribution. + /// + public static T[] RandomMap(int length, IContinuousDistribution distribution, Func map) + { + var data = new T[length]; + for (int i = 0; i < data.Length; i++) + { + data[i] = map(distribution.Sample()); + } + return data; + } + + /// + /// Generate a sample sequence by sampling a function at samples from a probability distribution. + /// + public static IEnumerable RandomMapSequence(IContinuousDistribution distribution, Func map) + { + return distribution.Samples().Select(map); + } + + /// + /// Generate samples by sampling a function at sample pairs from a probability distribution. + /// + public static T[] RandomMap2(int length, IContinuousDistribution distribution, Func map) + { + var data = new T[length]; + for (int i = 0; i < data.Length; i++) + { + data[i] = map(distribution.Sample(), distribution.Sample()); + } + return data; + } + + /// + /// Generate a sample sequence by sampling a function at sample pairs from a probability distribution. + /// + public static IEnumerable RandomMap2Sequence(IContinuousDistribution distribution, Func map) + { + return distribution.Samples().Zip(distribution.Samples(), map); + } + + /// + /// 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. + /// + public static T[] RandomUniformMap(int length, Func 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; + } + + /// + /// 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. + /// + public static IEnumerable RandomUniformMapSequence(Func map) + { + return SystemRandomSource.DoubleSequence().Select(map); + } + + /// + /// 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. + /// + public static T[] RandomUniformMap2(int length, Func 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; + } + + /// + /// 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. + /// + public static IEnumerable RandomUniformMap2Sequence(Func 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()); + } + } } }