Datasets:

introvoyz041
/

Dwsim

﻿/// ------------------------------------------------------
/// RandomOps - (Pseudo) Random Number Generator For C#
/// Copyright (C) 2003-2010 Magnus Erik Hvass Pedersen.
/// Please see the file license.txt for license details.
/// RandomOps on the internet: http://www.Hvass-Labs.org/
/// ------------------------------------------------------

using System;
using System.Diagnostics;

namespace RandomOps
{
    /// <summary>
    /// Pseudo-Random Number Generator (PRNG) based on the Ran2 algorithm from the book:
    /// 'Numerical Recipes in C' chapter 7.1 and which is originally
    /// due to L'Ecuyer with Bays-Durham shuffle and added safeguards.
    /// Period is greater than 2 * 10^18. Not thread-safe.
    /// </summary>
    /// <remarks>
    /// We MUST use division when generating random integers in a certain range.
    /// Do NOT use bit-manipulation because the low-order bits of are not that random!
    /// This works by default because Uniform() is used for creating integers through
    /// the implementation of the Index() methods in the Random base-class.
    /// </remarks>
    public class Ran2 : RanInt32
    {
        #region Constructors.
        /// <summary>
        /// Constructs the PRNG-object and seeds the PRNG with the current time of day.
        /// This is what you will mostly want to use.
        /// </summary>
        public Ran2()
            : base()
        {
            Seed();
        }

        /// <summary>
        /// Constructs the PRNG-object using the designated seed.
        /// This is useful if you want to repeat experiments with the
        /// same sequence of pseudo-random numbers.
        /// </summary>
        public Ran2(Int32 seed)
            : base()
        {
            Seed(seed);
        }
        #endregion

        #region Iterator-class (internal use only).
        class Iterator
        {
            Int32 IM, IA, IQ, IR;

            public Int32 Idum
            {
                get;
                private set;
            }

            public Iterator(Int32 im, Int32 ia, Int32 iq, Int32 ir)
            {
                IM = im;
                IA = ia;
                IQ = iq;
                IR = ir;
            }

            public void Seed(Int32 seed)
            {
                Idum = seed;
            }

            public Int32 DoRand()
            {
                Int32 k;

                k = Idum / IQ;

                Idum = IA * (Idum - k * IQ) - IR * k;

                if (Idum < 0)
                {
                    Idum += IM;
                }

                return Idum;
            }
        }
        #endregion

        #region Internal definitions and variables.
        static readonly Int32 IM0 = 2147483563;
        static readonly Int32 IM1 = 2147483399;
        static readonly Int32 IA0 = 40014;
        static readonly Int32 IA1 = 40692;
        static readonly Int32 IQ0 = 53668;
        static readonly Int32 IQ1 = 52774;
        static readonly Int32 IR0 = 12211;
        static readonly Int32 IR1 = 3791;
        static readonly Int32 NTAB = 32;
        static readonly Int32 IMM = IM0 - 1;
        static readonly Int32 NDIV = 1 + IMM / NTAB;
        static readonly Int32 WARMUP = 1024 + 8;
        static readonly Int32 WARMUP2 = 200;

        Iterator[] Iterators = { new Iterator(IM0, IA0, IQ0, IR0), new Iterator(IM1, IA1, IQ1, IR1) };

        Int32 iy = 0;
        Int32[] iv = new Int32[NTAB];

        /// <summary>
        /// Is PRNG ready for use?
        /// </summary>
        bool IsReady = false;
        #endregion

        #region PRNG Implementation.
        /// <summary>
        /// Draw a random number in inclusive range {0, .., RandMax}
        /// </summary>
        public sealed override Int32 Rand()
        {
            Debug.Assert(IsReady);

            Iterators[0].DoRand();
            Iterators[1].DoRand();

            {
                // Will be in the range 0..NTAB-1.
                int j = iy / NDIV;

                Debug.Assert(j >= 0 && j < NTAB);

                // Idum is shuffled, idum0 and idum1 are
                // combined to generate output.
                iy = iv[j] - Iterators[1].Idum;
                iv[j] = Iterators[0].Idum;

                if (iy < 1)
                {
                    iy += IMM;
                }
            }

            Debug.Assert(iy >= 0 && iy <= RandMax);

            return iy;
        }

        /// <summary>
        /// The maximum possible value returned by Rand().
        /// </summary>
        public sealed override Int32 RandMax
        {
            get { return IM0 - 1; }
        }

        /// <summary>
        /// Seed with an integer.
        /// </summary>
        protected sealed override void Seed(Int32 seed)
        {
            int j;

            // Ensure seed>0
            if (seed == 0)
            {
                seed = 1;
            }
            else if (seed < 0)
            {
                seed = -seed;
            }

            Iterators[0].Seed(seed);
            Iterators[1].Seed(seed);

            // Perform initial warm-ups.
            for (j = 0; j < WARMUP; j++)
            {
                Iterators[0].DoRand();
            }

            for (j = NTAB - 1; j >= 0; j--)
            {
                iv[j] = Iterators[0].DoRand();
            }

            iy = iv[0];

            // PRNG is now ready for use.
            IsReady = true;

            // Perform additional warm-ups.
            for (j = 0; j < WARMUP2; j++)
            {
                Rand();
            }
        }
        #endregion

        #region Base-class overrides.
        /// <summary>
        /// Name of the RNG.
        /// </summary>
        public override string Name
        {
            get { return "Ran2"; }
        }
        #endregion
    }
}

	/// ------------------------------------------------------
	/// RandomOps - (Pseudo) Random Number Generator For C#
	/// Copyright (C) 2003-2010 Magnus Erik Hvass Pedersen.
	/// Please see the file license.txt for license details.
	/// RandomOps on the internet: http://www.Hvass-Labs.org/
	/// ------------------------------------------------------

	using System;
	using System.Diagnostics;

	namespace RandomOps
	{
	/// <summary>
	/// Pseudo-Random Number Generator (PRNG) based on the Ran2 algorithm from the book:
	/// 'Numerical Recipes in C' chapter 7.1 and which is originally
	/// due to L'Ecuyer with Bays-Durham shuffle and added safeguards.
	/// Period is greater than 2 * 10^18. Not thread-safe.
	/// </summary>
	/// <remarks>
	/// We MUST use division when generating random integers in a certain range.
	/// Do NOT use bit-manipulation because the low-order bits of are not that random!
	/// This works by default because Uniform() is used for creating integers through
	/// the implementation of the Index() methods in the Random base-class.
	/// </remarks>
	public class Ran2 : RanInt32
	{
	#region Constructors.
	/// <summary>
	/// Constructs the PRNG-object and seeds the PRNG with the current time of day.
	/// This is what you will mostly want to use.
	/// </summary>
	public Ran2()
	: base()
	{
	Seed();
	}

	/// <summary>
	/// Constructs the PRNG-object using the designated seed.
	/// This is useful if you want to repeat experiments with the
	/// same sequence of pseudo-random numbers.
	/// </summary>
	public Ran2(Int32 seed)
	: base()
	{
	Seed(seed);
	}
	#endregion

	#region Iterator-class (internal use only).
	class Iterator
	{
	Int32 IM, IA, IQ, IR;

	public Int32 Idum
	{
	get;
	private set;
	}

	public Iterator(Int32 im, Int32 ia, Int32 iq, Int32 ir)
	{
	IM = im;
	IA = ia;
	IQ = iq;
	IR = ir;
	}

	public void Seed(Int32 seed)
	{
	Idum = seed;
	}

	public Int32 DoRand()
	{
	Int32 k;

	k = Idum / IQ;

	Idum = IA * (Idum - k * IQ) - IR * k;

	if (Idum < 0)
	{
	Idum += IM;
	}

	return Idum;
	}
	}
	#endregion

	#region Internal definitions and variables.
	static readonly Int32 IM0 = 2147483563;
	static readonly Int32 IM1 = 2147483399;
	static readonly Int32 IA0 = 40014;
	static readonly Int32 IA1 = 40692;
	static readonly Int32 IQ0 = 53668;
	static readonly Int32 IQ1 = 52774;
	static readonly Int32 IR0 = 12211;
	static readonly Int32 IR1 = 3791;
	static readonly Int32 NTAB = 32;
	static readonly Int32 IMM = IM0 - 1;
	static readonly Int32 NDIV = 1 + IMM / NTAB;
	static readonly Int32 WARMUP = 1024 + 8;
	static readonly Int32 WARMUP2 = 200;

	Iterator[] Iterators = { new Iterator(IM0, IA0, IQ0, IR0), new Iterator(IM1, IA1, IQ1, IR1) };

	Int32 iy = 0;
	Int32[] iv = new Int32[NTAB];

	/// <summary>
	/// Is PRNG ready for use?
	/// </summary>
	bool IsReady = false;
	#endregion

	#region PRNG Implementation.
	/// <summary>
	/// Draw a random number in inclusive range {0, .., RandMax}
	/// </summary>
	public sealed override Int32 Rand()
	{
	Debug.Assert(IsReady);

	Iterators[0].DoRand();
	Iterators[1].DoRand();

	{
	// Will be in the range 0..NTAB-1.
	int j = iy / NDIV;

	Debug.Assert(j >= 0 && j < NTAB);

	// Idum is shuffled, idum0 and idum1 are
	// combined to generate output.
	iy = iv[j] - Iterators[1].Idum;
	iv[j] = Iterators[0].Idum;

	if (iy < 1)
	{
	iy += IMM;
	}
	}

	Debug.Assert(iy >= 0 && iy <= RandMax);

	return iy;
	}

	/// <summary>
	/// The maximum possible value returned by Rand().
	/// </summary>
	public sealed override Int32 RandMax
	{
	get { return IM0 - 1; }
	}

	/// <summary>
	/// Seed with an integer.
	/// </summary>
	protected sealed override void Seed(Int32 seed)
	{
	int j;

	// Ensure seed>0
	if (seed == 0)
	{
	seed = 1;
	}
	else if (seed < 0)
	{
	seed = -seed;
	}

	Iterators[0].Seed(seed);
	Iterators[1].Seed(seed);

	// Perform initial warm-ups.
	for (j = 0; j < WARMUP; j++)
	{
	Iterators[0].DoRand();
	}

	for (j = NTAB - 1; j >= 0; j--)
	{
	iv[j] = Iterators[0].DoRand();
	}

	iy = iv[0];

	// PRNG is now ready for use.
	IsReady = true;

	// Perform additional warm-ups.
	for (j = 0; j < WARMUP2; j++)
	{
	Rand();
	}
	}
	#endregion

	#region Base-class overrides.
	/// <summary>
	/// Name of the RNG.
	/// </summary>
	public override string Name
	{
	get { return "Ran2"; }
	}
	#endregion
	}
	}