using System;

using System.IO;

namespace NumSharp

{

/// <summary>

/// Represents a pseudo-random number generator, which is a device that produces a sequence of numbers that meet certain statistical requirements for randomness.<br></br>

/// Equivalent of <see cref="System.Random"/> but with a <see cref="SerializableAttribute"/>.

/// </summary>

/// <remarks>Copied and modified from https://referencesource.microsoft.com/#mscorlib/system/random.cs</remarks>

[Serializable]

public sealed class Randomizer : ICloneable

{

private const int MBIG = int.MaxValue;

private const long MBIG_LONG = long.MaxValue;

private const int MSEED = 161803398;

private const int MZ = 0;

private int inext;

private int inextp;

private const int seedArrayLength = 56;

// ReSharper disable once FieldCanBeMadeReadOnly.Local

private int[] SeedArray = new int[seedArrayLength];

/// <summary>Initializes a new instance of the <see cref="Randomizer" /> class, using a time-dependent default seed value.</summary>

public Randomizer()

: this(Environment.TickCount)

{ }

/// <summary>Initializes a new instance of the <see cref="T:System.Random" /> class, using the specified seed value.</summary>

/// <param name="Seed">A number used to calculate a starting value for the pseudo-random number sequence. If a negative number is specified, the absolute value of the number is used.</param>

public Randomizer(int Seed)

{

int ii;

int mj, mk;

//Initialize our Seed array.

//This algorithm comes from Numerical Recipes in C (2nd Ed.)

int subtraction = (Seed == int.MinValue) ? int.MaxValue : Math.Abs(Seed);

mj = MSEED - subtraction;

SeedArray[55] = mj;

mk = 1;

for (int i = 1; i < 55; i++)

{

//Apparently the range [1..55] is special (Knuth) and so we're wasting the 0'th position.

ii = (21 * i) % 55;

SeedArray[ii] = mk;

mk = mj - mk;

if (mk < 0) mk += MBIG;

mj = SeedArray[ii];

}

for (int k = 1; k < 5; k++)

{

for (int i = 1; i < 56; i++)

{

SeedArray[i] -= SeedArray[1 + (i + 30) % 55];

if (SeedArray[i] < 0) SeedArray[i] += MBIG;

}

}

inext = 0;

inextp = 21;

Seed = 1;

}

//

// Package Private Methods

//

/*====================================Sample====================================

**Action: Return a new random number [0..1) and reSeed the Seed array.

**Returns: A double [0..1)

**Arguments: None

**Exceptions: None

==============================================================================*/

/// <summary>Returns a random floating-point number between 0.0 and 1.0.</summary>

/// <returns>A double-precision floating point number that is greater than or equal to 0.0, and less than 1.0.</returns>

protected double Sample()

{

//Including this division at the end gives us significantly improved

//random number distribution.

int retVal;

int locINext = inext;

int locINextp = inextp;

if (++locINext >= 56) locINext = 1;

if (++locINextp >= 56) locINextp = 1;

retVal = SeedArray[locINext] - SeedArray[locINextp];

if (retVal == MBIG) retVal--;

if (retVal < 0) retVal += MBIG;

SeedArray[locINext] = retVal;

inext = locINext;

inextp = locINextp;

return retVal * (1.0 / MBIG);

}

private int InternalSample()

{

int retVal;

int locINext = inext;

int locINextp = inextp;

if (++locINext >= 56) locINext = 1;

if (++locINextp >= 56) locINextp = 1;

retVal = SeedArray[locINext] - SeedArray[locINextp];

if (retVal == MBIG) retVal--;

if (retVal < 0) retVal += MBIG;

SeedArray[locINext] = retVal;

inext = locINext;

inextp = locINextp;

return retVal;

}

/// <summary>

/// Returns a value between 0 and <see cref="long"/>.<see cref="long.MaxValue"/>.

/// </summary>

/// <returns></returns>

private long InternalSampleLong()

{

const double factor = long.MaxValue / int.MaxValue;

int retVal;

int locINext = inext;

int locINextp = inextp;

if (++locINext >= 56) locINext = 1;

if (++locINextp >= 56) locINextp = 1;

retVal = SeedArray[locINext] - SeedArray[locINextp];

if (retVal == MBIG) retVal--;

if (retVal < 0) retVal += MBIG;

SeedArray[locINext] = retVal;

inext = locINext;

inextp = locINextp;

return (long)(retVal * factor);

}

//

// Public Instance Methods

//

/*=====================================Next=====================================

**Returns: An int [0..Int32.MaxValue)

**Arguments: None

**Exceptions: None.

==============================================================================*/

/// <summary>Returns a non-negative random integer.</summary>

/// <returns>A 32-bit signed integer that is greater than or equal to 0 and less than <see cref="F:System.Int32.MaxValue" />.</returns>

public int Next()

{

int retVal;

int locINext = inext;

int locINextp = inextp;

if (++locINext >= 56) locINext = 1;

if (++locINextp >= 56) locINextp = 1;

retVal = SeedArray[locINext] - SeedArray[locINextp];

if (retVal == MBIG) retVal--;

if (retVal < 0) retVal += MBIG;

SeedArray[locINext] = retVal;

inext = locINext;

inextp = locINextp;

return retVal;

}

private double GetSampleForLargeRange()

{

// The distribution of double value returned by Sample

// is not distributed well enough for a large range.

// If we use Sample for a range [Int32.MinValue..Int32.MaxValue)

// We will end up getting even numbers only.

int retVal;

int locINext = inext;

int locINextp = inextp;

if (++locINext >= 56) locINext = 1;

if (++locINextp >= 56) locINextp = 1;

retVal = SeedArray[locINext] - SeedArray[locINextp];

if (retVal == MBIG) retVal--;

if (retVal < 0) retVal += MBIG;

SeedArray[locINext] = retVal;

var result = retVal;

if (++locINext >= 56) locINext = 1;

if (++locINextp >= 56) locINextp = 1;

retVal = SeedArray[locINext] - SeedArray[locINextp];

if (retVal == MBIG) retVal--;

if (retVal < 0) retVal += MBIG;

SeedArray[locINext] = retVal;

inext = locINext;

inextp = locINextp;

// Note we can't use addition here. The distribution will be bad if we do that.

bool negative = (retVal % 2 == 0) ? true : false; // decide the sign based on second sample

if (negative)

{

result = -result;

}

double d = result;

d += (int.MaxValue - 1); // get a number in range [0 .. 2 * Int32MaxValue - 1)

d /= 2 * (uint)int.MaxValue - 1;

return d;

}

/*=====================================Next=====================================

**Returns: An int [minvalue..maxvalue)

**Arguments: minValue -- the least legal value for the Random number.

** maxValue -- One greater than the greatest legal return value.

**Exceptions: None.

==============================================================================*/

/// <summary>Returns a random integer that is 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 int Next(int minValue, int maxValue)

{

if (minValue > maxValue)

{

//swap

var tmp = minValue;

minValue = maxValue;

maxValue = tmp;

}

long range = (long)maxValue - minValue;

if (range <= int.MaxValue)

{

return ((int)(Sample() * range) + minValue);

}

else

{

return (int)((long)(GetSampleForLargeRange() * range) + minValue);

}

}

/*=====================================Next=====================================

**Returns: An int [0..maxValue)

**Arguments: maxValue -- One more than the greatest legal return value.

**Exceptions: None.

==============================================================================*/

/// <summary>Returns a non-negative random integer that is less than the specified maximum.</summary>

/// <param name="maxValue">The exclusive upper bound of the random number to be generated. <paramref name="maxValue" /> must be greater than or equal to 0.</param>

/// <returns>A 32-bit signed integer that is greater than or equal to 0, and less than <paramref name="maxValue" />; that is, the range of return values ordinarily includes 0 but not <paramref name="maxValue" />. However, if <paramref name="maxValue" /> equals 0, <paramref name="maxValue" /> is returned.</returns>

/// <exception cref="T:System.ArgumentOutOfRangeException">

/// <paramref name="maxValue" /> is less than 0.</exception>

public long NextLong(long maxValue)

{

return (long)(Sample() * maxValue);

}

/// <summary>Returns a non-negative random integer that is less than the specified maximum.</summary>

/// <param name="maxValue">The exclusive upper bound of the random number to be generated. <paramref name="maxValue" /> must be greater than or equal to 0.</param>

/// <returns>A 32-bit signed integer that is greater than or equal to 0, and less than <paramref name="maxValue" />; that is, the range of return values ordinarily includes 0 but not <paramref name="maxValue" />. However, if <paramref name="maxValue" /> equals 0, <paramref name="maxValue" /> is returned.</returns>

/// <exception cref="T:System.ArgumentOutOfRangeException">

/// <paramref name="maxValue" /> is less than 0.</exception>

public long NextLong()

{

return InternalSampleLong();

}

/*=====================================Next=====================================

**Returns: An int [minvalue..maxvalue)

**Arguments: minValue -- the least legal value for the Random number.

** maxValue -- One greater than the greatest legal return value.

**Exceptions: None.

==============================================================================*/

/// <summary>Returns a random integer that is 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 long NextLong(long minValue, long maxValue)

{

if (minValue > maxValue)

{

//swap

var tmp = minValue;

minValue = maxValue;

maxValue = tmp;

}

long range = maxValue - minValue;

if (range <= int.MaxValue)

{

return (long)(Sample() * range + minValue);

}

else

{

return (long)(GetSampleForLargeRange() * range) + minValue;

}

}

/*=====================================Next=====================================

**Returns: An int [0..maxValue)

**Arguments: maxValue -- One more than the greatest legal return value.

**Exceptions: None.

==============================================================================*/

/// <summary>Returns a non-negative random integer that is less than the specified maximum.</summary>

/// <param name="maxValue">The exclusive upper bound of the random number to be generated. <paramref name="maxValue" /> must be greater than or equal to 0.</param>

/// <returns>A 32-bit signed integer that is greater than or equal to 0, and less than <paramref name="maxValue" />; that is, the range of return values ordinarily includes 0 but not <paramref name="maxValue" />. However, if <paramref name="maxValue" /> equals 0, <paramref name="maxValue" /> is returned.</returns>

/// <exception cref="T:System.ArgumentOutOfRangeException">

/// <paramref name="maxValue" /> is less than 0.</exception>

public int Next(int maxValue)

{

//Including this division at the end gives us significantly improved

//random number distribution.

int retVal;

int locINext = inext;

int locINextp = inextp;

if (++locINext >= 56) locINext = 1;

if (++locINextp >= 56) locINextp = 1;

retVal = SeedArray[locINext] - SeedArray[locINextp];

if (retVal == MBIG) retVal--;

if (retVal < 0) retVal += MBIG;

SeedArray[locINext] = retVal;

inext = locINext;

inextp = locINextp;

return (int) (retVal * (1.0 / MBIG) * maxValue);

}

/*=====================================Next=====================================

**Returns: A double [0..1)

**Arguments: None

**Exceptions: None

==============================================================================*/

/// <summary>Returns a random floating-point number that is greater than or equal to 0.0, and less than 1.0.</summary>

/// <returns>A double-precision floating point number that is greater than or equal to 0.0, and less than 1.0.</returns>

public double NextDouble()

{

//Including this division at the end gives us significantly improved

//random number distribution.

int retVal;

int locINext = inext;

int locINextp = inextp;

if (++locINext >= 56) locINext = 1;

if (++locINextp >= 56) locINextp = 1;

retVal = SeedArray[locINext] - SeedArray[locINextp];

if (retVal == MBIG) retVal--;

if (retVal < 0) retVal += MBIG;

SeedArray[locINext] = retVal;

inext = locINext;

inextp = locINextp;

return retVal * (1.0 / MBIG);

}

/*==================================NextBytes===================================

**Action: Fills the byte array with random bytes [0..0x7f]. The entire array is filled.

**Returns:Void

**Arugments: buffer -- the array to be filled.

**Exceptions: None

==============================================================================*/

/// <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 <see langword="null" />.</exception>

public void NextBytes(byte[] buffer)

{

int retVal;

int locINext = inext;

int locINextp = inextp;

for (int i = 0; i < buffer.Length; i++)

{

if (++locINext >= 56) locINext = 1;

if (++locINextp >= 56) locINextp = 1;

retVal = SeedArray[locINext] - SeedArray[locINextp];

if (retVal == MBIG) retVal--;

if (retVal < 0) retVal += MBIG;

SeedArray[locINext] = retVal;

buffer[i] = (byte)(retVal % 256);

}

inext = locINext;

inextp = locINextp;

}

/// <summary>Creates a new object that is a copy of the current instance.</summary>

/// <returns>A new object that is a copy of this instance.</returns>

object ICloneable.Clone()

{

return Clone();

}

/// <summary>Creates a new object that is a copy of the current instance.</summary>

/// <returns>A new object that is a copy of this instance.</returns>

public Randomizer Clone()

{

return new Randomizer() {SeedArray = (int[])SeedArray.Clone(), inext = inext, inextp = inextp};

}

public byte[] Serialize()

{

using (MemoryStream stream = new MemoryStream())

{

using (BinaryWriter writer = new BinaryWriter(stream))

{

for (int i = 0; i < seedArrayLength; i++)

{

writer.Write(SeedArray[i]);

}

writer.Write(inext);

writer.Write(inextp);

}

return stream.ToArray();

}

}

public static Randomizer Deserialize(byte[] bytes)

{

using (MemoryStream stream = new MemoryStream(bytes))

{

using (BinaryReader reader = new BinaryReader(stream))

{

var rnd = new Randomizer();

for (int i = 0; i < seedArrayLength; i++)

{

rnd.SeedArray[i] = reader.ReadInt32();

}

rnd.inext = reader.ReadInt32();

rnd.inextp = reader.ReadInt32();

return rnd;

}

}

}

}

internal static class MemoryStreamExtensions

{

public static void Append(this MemoryStream stream, byte value)

{

stream.Append(new[] {value});

}

public static void Append(this MemoryStream stream, byte[] values)

{

stream.Write(values, 0, values.Length);

}

}

}