【原创】开源Math.NET基础数学类库使用(13)C#实现其他随机数生成器

public abstract class RandomSource : System.Random
{
readonly bool _threadSafe;
readonly object _lock = new object(); /// <summary>
/// Initializes a new instance of the <see cref="RandomSource"/> class using
/// the value of <see cref="Control.ThreadSafeRandomNumberGenerators"/> to set whether
/// the instance is thread safe or not.
/// </summary>
protected RandomSource() : base(RandomSeed.Robust())
{
_threadSafe = Control.ThreadSafeRandomNumberGenerators;
} /// <summary>
/// Initializes a new instance of the <see cref="RandomSource"/> class.
/// </summary>
/// <param name="threadSafe">if set to <c>true</c> , the class is thread safe.</param>
/// <remarks>Thread safe instances are two and half times slower than non-thread
/// safe classes.</remarks>
protected RandomSource(bool threadSafe) : base(RandomSeed.Robust())
{
_threadSafe = threadSafe;
} /// <summary>
/// Fills an array with uniform random numbers greater than or equal to 0.0 and less than 1.0.
/// </summary>
/// <param name="values">The array to fill with random values.</param>
public void NextDoubles(double[] values)
{
if (_threadSafe)
{
lock (_lock)
{
for (var i = ; i < values.Length; i++)
{
values[i] = DoSample();
}
}
}
else
{
for (var i = ; i < values.Length; i++)
{
values[i] = DoSample();
}
}
} /// <summary>
/// Returns an infinite sequence of uniform random numbers greater than or equal to 0.0 and less than 1.0.
/// </summary>
public IEnumerable<double> NextDoubleSequence()
{
for (int i = ; i < ; i++)
{
yield return NextDouble();
} var buffer = new double[];
while (true)
{
NextDoubles(buffer);
for (int i = ; i < buffer.Length; i++)
{
yield return buffer[i];
}
}
} /// <summary>
/// Returns a nonnegative random number.
/// </summary>
/// <returns>
/// A 32-bit signed integer greater than or equal to zero and less than <see cref="F:System.Int32.MaxValue"/>.
/// </returns>
public override sealed int Next()
{
if (_threadSafe)
{
lock (_lock)
{
return (int)(DoSample()*int.MaxValue);
}
} return (int)(DoSample()*int.MaxValue);
} /// <summary>
/// Returns a random number less then a specified maximum.
/// </summary>
/// <param name="maxValue">The exclusive upper bound of the random number returned.</param>
/// <returns>A 32-bit signed integer less than <paramref name="maxValue"/>.</returns>
/// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="maxValue"/> is negative. </exception>
public override sealed int Next(int maxValue)
{
if (maxValue <= )
{
throw new ArgumentException(Resources.ArgumentMustBePositive);
} if (_threadSafe)
{
lock (_lock)
{
return (int)(DoSample()*maxValue);
}
} return (int)(DoSample()*maxValue);
} /// <summary>
/// Returns a random number within a specified range.
/// </summary>
/// <param name="minValue">The inclusive lower bound of the random number returned.</param>
/// <param name="maxValue">The exclusive upper bound of the random number returned. <paramref name="maxValue"/> must be greater than or equal to <paramref name="minValue"/>.</param>
/// <returns>
/// A 32-bit signed integer greater than or equal to <paramref name="minValue"/> and less than <paramref name="maxValue"/>; that is, the range of return values includes <paramref name="minValue"/> but not <paramref name="maxValue"/>. If <paramref name="minValue"/> equals <paramref name="maxValue"/>, <paramref name="minValue"/> is returned.
/// </returns>
/// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="minValue"/> is greater than <paramref name="maxValue"/>. </exception>
public override sealed int Next(int minValue, int maxValue)
{
if (minValue > maxValue)
{
throw new ArgumentException(Resources.ArgumentMinValueGreaterThanMaxValue);
} if (_threadSafe)
{
lock (_lock)
{
return (int)(DoSample()*(maxValue - minValue)) + minValue;
}
} return (int)(DoSample()*(maxValue - minValue)) + minValue;
} /// <summary>
/// Fills an array with random numbers within a specified range.
/// </summary>
/// <param name="values">The array to fill with random values.</param>
/// <param name="minValue">The inclusive lower bound of the random number returned.</param>
/// <param name="maxValue">The exclusive upper bound of the random number returned. <paramref name="maxValue"/> must be greater than or equal to <paramref name="minValue"/>.</param>
public void NextInt32s(int[] values, int minValue, int maxValue)
{
if (_threadSafe)
{
lock (_lock)
{
for (var i = ; i < values.Length; i++)
{
values[i] = (int)(DoSample()*(maxValue - minValue)) + minValue;
}
}
}
else
{
for (var i = ; i < values.Length; i++)
{
values[i] = (int)(DoSample()*(maxValue - minValue)) + minValue;
}
}
} /// <summary>
/// Returns an infinite sequence of random numbers within a specified range.
/// </summary>
/// <param name="minValue">The inclusive lower bound of the random number returned.</param>
/// <param name="maxValue">The exclusive upper bound of the random number returned. <paramref name="maxValue"/> must be greater than or equal to <paramref name="minValue"/>.</param>
public IEnumerable<int> NextInt32Sequence(int minValue, int maxValue)
{
for (int i = ; i < ; i++)
{
yield return Next(minValue, maxValue);
} var buffer = new int[];
while (true)
{
NextInt32s(buffer, minValue, maxValue);
for (int i = ; i < buffer.Length; i++)
{
yield return buffer[i];
}
}
} /// <summary>
/// Fills the elements of a specified array of bytes with random numbers.
/// </summary>
/// <param name="buffer">An array of bytes to contain random numbers.</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="buffer"/> is null. </exception>
public override void NextBytes(byte[] buffer)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
} if (_threadSafe)
{
lock (_lock)
{
for (var i = ; i < buffer.Length; i++)
{
buffer[i] = (byte)(((int)(DoSample()*int.MaxValue))%);
}
} return;
} for (var i = ; i < buffer.Length; i++)
{
buffer[i] = (byte)(((int)(DoSample()*int.MaxValue))%);
}
} /// <summary>
/// Returns a random number between 0.0 and 1.0.
/// </summary>
/// <returns>A double-precision floating point number greater than or equal to 0.0, and less than 1.0.</returns>
protected override sealed double Sample()
{
if (_threadSafe)
{
lock (_lock)
{
return DoSample();
}
} return DoSample();
} /// <summary>
/// Returns a random number between 0.0 and 1.0.
/// </summary>
/// <returns>
/// A double-precision floating point number greater than or equal to 0.0, and less than 1.0.
/// </returns>
protected abstract double DoSample();
}

public class Mcg59 : RandomSource
{
const ulong Modulus = ;
const ulong Multiplier = ;
const double Reciprocal = 1.0/Modulus;
ulong _xn; /// <summary>
/// Initializes a new instance of the <see cref="Mcg59"/> class using
/// a seed based on time and unique GUIDs.
/// </summary>
public Mcg59() : this(RandomSeed.Robust())
{
} /// <summary>
/// Initializes a new instance of the <see cref="Mcg59"/> class using
/// a seed based on time and unique GUIDs.
/// </summary>
/// <param name="threadSafe">if set to <c>true</c> , the class is thread safe.</param>
public Mcg59(bool threadSafe) : this(RandomSeed.Robust(), threadSafe)
{
} /// <summary>
/// Initializes a new instance of the <see cref="Mcg59"/> class.
/// </summary>
/// <param name="seed">The seed value.</param>
/// <remarks>If the seed value is zero, it is set to one. Uses the
/// value of <see cref="Control.ThreadSafeRandomNumberGenerators"/> to
/// set whether the instance is thread safe.</remarks>
public Mcg59(int seed)
{
if (seed == )
{
seed = ;
} _xn = (uint)seed%Modulus;
} /// <summary>
/// Initializes a new instance of the <see cref="Mcg59"/> class.
/// </summary>
/// <param name="seed">The seed value.</param>
/// <remarks>The seed is set to 1, if the zero is used as the seed.</remarks>
/// <param name="threadSafe">if set to <c>true</c> , the class is thread safe.</param>
public Mcg59(int seed, bool threadSafe) : base(threadSafe)
{
if (seed == )
{
seed = ;
} _xn = (uint)seed%Modulus;
} /// <summary>
/// Returns a random number between 0.0 and 1.0.
/// </summary>
/// <returns>
/// A double-precision floating point number greater than or equal to 0.0, and less than 1.0.
/// </returns>
protected override sealed double DoSample()
{
double ret = _xn*Reciprocal;
_xn = (_xn*Multiplier)%Modulus;
return ret;
} /// <summary>
/// Fills an array with random numbers greater than or equal to 0.0 and less than 1.0.
/// </summary>
/// <remarks>Supports being called in parallel from multiple threads.</remarks>
public static void Doubles(double[] values, int seed)
{
if (seed == )
{
seed = ;
} ulong xn = (uint)seed%Modulus; for (int i = ; i < values.Length; i++)
{
values[i] = xn*Reciprocal;
xn = (xn*Multiplier)%Modulus;
}
} /// <summary>
/// Returns an array of random numbers greater than or equal to 0.0 and less than 1.0.
/// </summary>
/// <remarks>Supports being called in parallel from multiple threads.</remarks>
[TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
public static double[] Doubles(int length, int seed)
{
var data = new double[length];
Doubles(data, seed);
return data;
} /// <summary>
/// Returns an infinite sequence of random numbers greater than or equal to 0.0 and less than 1.0.
/// </summary>
/// <remarks>Supports being called in parallel from multiple threads, but the result must be enumerated from a single thread each.</remarks>
public static IEnumerable<double> DoubleSequence(int seed)
{
if (seed == )
{
seed = ;
} ulong xn = (uint)seed%Modulus; while (true)
{
yield return xn*Reciprocal;
xn = (xn*Multiplier)%Modulus;
}
}
}