The Mersenne Twister - please help

M

Martin Ho

Hi Everyone,
I have this code of Mersenne twister, which produces the random
numbers, one of the fastest codes as far as I know to produce random
numbers.
Anyways, it's writen in c# and I need to translate it to vb.net.
I tried some translators and I can't get it to work.
Could someone help me?

This is the code:


using System;

namespace CenterSpace.Free
{
/// <summary>
/// Class MersenneTwister generates random numbers from a uniform
distribution using
/// the Mersenne Twister algorithm.
/// </summary>
/// <remarks>Caution: MT is for MonteCarlo, and is NOT
SECURE for CRYPTOGRAPHY
/// as it is.</remarks>
public class MersenneTwister
{
#region Constants
-------------------------------------------------------

// Period parameters.
private const int N = 624;
private const int M = 397;
private const uint MATRIX_A = 0x9908b0dfU; // constant vector a
private const uint UPPER_MASK = 0x80000000U; // most significant
w-r bits
private const uint LOWER_MASK = 0x7fffffffU; // least significant
r bits
private const int MAX_RAND_INT = 0x7fffffff;

#endregion Constants

#region Instance Variables
----------------------------------------------

// mag01[x] = x * MATRIX_A for x=0,1
private uint[] mag01 = {0x0U, MATRIX_A};

// the array for the state vector
private uint[] mt = new uint[N];

// mti==N+1 means mt[N] is not initialized
private int mti = N+1;

#endregion Instance Variables

#region Constructors
----------------------------------------------------

/// <summary>
/// Creates a random number generator using the time of day in
milliseconds as
/// the seed.
/// </summary>
public MersenneTwister()
{
init_genrand( (uint)DateTime.Now.Millisecond );
}

/// <summary>
/// Creates a random number generator initialized with the given
seed.
/// </summary>
/// <param name="seed">The seed.</param>
public MersenneTwister( int seed )
{
init_genrand( (uint)seed );
}

/// <summary>
/// Creates a random number generator initialized with the given
array.
/// </summary>
/// <param name="init">The array for initializing
keys.</param>
public MersenneTwister( int[] init )
{
uint[] initArray = new uint[init.Length];
for ( int i = 0; i < init.Length; ++i )
initArray = (uint)init;

init_by_array( initArray, (uint)initArray.Length
);
}

#endregion Constructors

#region Properties
------------------------------------------------------

/// <summary>
/// Gets the maximum random integer value. All random integers
generated
/// by instances of this class are less than or equal to this
value. This
/// value is <c>0x7fffffff</c>
(<c>2,147,483,647</c>).
/// </summary>
public static int MaxRandomInt
{
get
{
return 0x7fffffff;
}
}

#endregion Properties

#region Member Functions
------------------------------------------------

/// <summary>
/// Returns a random integer greater than or equal to zero and
/// less than or equal to <c>MaxRandomInt</c>.
/// </summary>
/// <returns>The next random integer.</returns>
public int Next()
{
return genrand_int31();
}

/// <summary>
/// Returns a positive random integer less than the specified
maximum.
/// </summary>
/// <param name="maxValue">The maximum value. Must
be greater than zero.</param>
/// <returns>A positive random integer less than or equal to
<c>maxValue</c>.</returns>
public int Next( int maxValue )
{
return Next( 0, maxValue );
}

/// <summary>
/// Returns a random integer within the specified range.
/// </summary>
/// <param name="minValue">The lower
bound.</param>
/// <param name="maxValue">The upper
bound.</param>
/// <returns>A random integer greater than or equal to
<c>minValue</c>, and less than
/// or equal to <c>maxValue</c>.</returns>
public int Next( int minValue, int maxValue )
{
if ( minValue > maxValue )
{
int tmp = maxValue;
maxValue = minValue;
minValue = tmp;
}

return (int)(
Math.Floor((maxValue-minValue+1)*genrand_real1()
+ minValue) );
}

/// <summary>
/// Returns a random number between 0.0 and 1.0.
/// </summary>
/// <returns>A single-precision floating point number
greater than or equal to 0.0,
/// and less than 1.0.</returns>
public float NextFloat()
{
return (float) genrand_real2();
}

/// <summary>
/// Returns a random number greater than or equal to zero, and
either strictly
/// less than one, or less than or equal to one, depending on the
value of the
/// given boolean parameter.
/// </summary>
/// <param name="includeOne">
/// If <c>true</c>, the random number returned will be

/// less than or equal to one; otherwise, the random number
returned will
/// be strictly less than one.
/// </param>
/// <returns>
/// If <c>includeOne</c> is <c>true</c>,
this method returns a
/// single-precision random number greater than or equal to zero,
and less
/// than or equal to one. If <c>includeOne</c> is
<c>false</c>, this method
/// returns a single-precision random number greater than or equal
to zero and
/// strictly less than one.
/// </returns>
public float NextFloat( bool includeOne )
{
if ( includeOne )
{
return (float) genrand_real1();
}
return (float) genrand_real2();
}

/// <summary>
/// Returns a random number greater than 0.0 and less than 1.0.
/// </summary>
/// <returns>A random number greater than 0.0 and less than
1.0.</returns>
public float NextFloatPositive()
{
return (float) genrand_real3();
}

/// <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>
public double NextDouble()
{
return genrand_real2();
}

/// <summary>
/// Returns a random number greater than or equal to zero, and
either strictly
/// less than one, or less than or equal to one, depending on the
value of the
/// given boolean parameter.
/// </summary>
/// <param name="includeOne">
/// If <c>true</c>, the random number returned will be

/// less than or equal to one; otherwise, the random number
returned will
/// be strictly less than one.
/// </param>
/// <returns>
/// If <c>includeOne</c> is <c>true</c>,
this method returns a
/// single-precision random number greater than or equal to zero,
and less
/// than or equal to one. If <c>includeOne</c> is
<c>false</c>, this method
/// returns a single-precision random number greater than or equal
to zero and
/// strictly less than one.
/// </returns>
public double NextDouble( bool includeOne )
{
if ( includeOne )
{
return genrand_real1();
}
return genrand_real2();
}

/// <summary>
/// Returns a random number greater than 0.0 and less than 1.0.
/// </summary>
/// <returns>A random number greater than 0.0 and less than
1.0.</returns>
public double NextDoublePositive()
{
return genrand_real3();
}

/// <summary>
/// Generates a random number on <c>[0,1)</c>
with 53-bit resolution.
/// </summary>
/// <returns>A random number on
<c>[0,1)</c> with 53-bit
resolution</returns>
public double Next53BitRes()
{
return genrand_res53();
}

/// <summary>
/// Reinitializes the random number generator using the time of
day in
/// milliseconds as the seed.
/// </summary>
public void Initialize()
{
init_genrand( (uint)DateTime.Now.Millisecond );
}


/// <summary>
/// Reinitializes the random number generator with the given
seed.
/// </summary>
/// <param name="seed">The seed.</param>
public void Initialize( int seed )
{
init_genrand( (uint)seed );
}

/// <summary>
/// Reinitializes the random number generator with the given
array.
/// </summary>
/// <param name="init">The array for initializing
keys.</param>
public void Initialize( int[] init )
{
uint[] initArray = new uint[init.Length];
for ( int i = 0; i < init.Length; ++i )
initArray = (uint)init;

init_by_array( initArray, (uint)initArray.Length
);
}


#region Methods ported from C
-------------------------------------------

// initializes mt[N] with a seed
private void init_genrand( uint s)
{
mt[0]= s & 0xffffffffU;
for (mti=1; mti<N; mti++)
{
mt[mti] =
(uint)(1812433253U * (mt[mti-1] ^
(mt[mti-1] >> 30)) + mti);
// See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier.
// In the previous versions, MSBs of the seed affect
// only MSBs of the array mt[].

// 2002/01/09 modified by Makoto Matsumoto
mt[mti] &= 0xffffffffU;
// for >32 bit machines
}
}

// initialize by an array with array-length
// init_key is the array for initializing keys
// key_length is its length
private void init_by_array(uint[] init_key, uint
key_length)
{
int i, j, k;
init_genrand(19650218U);
i=1; j=0;
k = (int)(N>key_length ? N :
key_length);
for (; k>0; k--)
{
mt =
(uint)((uint)(mt ^
((mt[i-1] ^ (mt[i-1] >>
30)) * 1664525U)) + init_key[j] + j); /*
non linear */
mt &= 0xffffffffU; // for WORDSIZE > 32
machines
i++; j++;
if (i>=N) { mt[0] = mt[N-1];
i=1; }
if (j>=key_length) j=0;
}
for (k=N-1; k>0; k--)
{
mt =
(uint)((uint)(mt ^
((mt[i-1] ^ (mt[i-1] >>
30)) * 1566083941U))- i); /* non linear */
mt &= 0xffffffffU; // for WORDSIZE > 32
machines
i++;
if (i>=N) { mt[0] = mt[N-1];
i=1; }
}

mt[0] = 0x80000000U; // MSB is 1; assuring non-zero
initial array
}

// generates a random number on [0,0xffffffff]-interval
uint genrand_int32()
{
uint y;
if (mti >= N)
{ /* generate N words at one time */
int kk;

if (mti == N+1) /* if init_genrand() has not
been called, */
init_genrand(5489U); /* a default initial seed is
used */

for (kk=0;kk<N-M;kk++)
{
y =
(mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
mt[kk] = mt[kk+M] ^ (y >> 1) ^
mag01[y & 0x1U];
}
for (;kk<N-1;kk++)
{
y =
(mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
mt[kk] = mt[kk+(M-N)] ^ (y
1) ^ mag01[y & 0x1U];
}
y =
(mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
mt[N-1] = mt[M-1] ^ (y >> 1) ^
mag01[y & 0x1U];

mti = 0;
}

y = mt[mti++];

// Tempering
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680U;
y ^= (y << 15) & 0xefc60000U;
y ^= (y >> 18);

return y;
}

// generates a random number on [0,0x7fffffff]-interval
private int genrand_int31()
{
return (int)(genrand_int32()>>1);
}

// generates a random number on [0,1]-real-interval
double genrand_real1()
{
return genrand_int32()*(1.0/4294967295.0);
// divided by 2^32-1
}

// generates a random number on [0,1)-real-interval
double genrand_real2()
{
return genrand_int32()*(1.0/4294967296.0);
// divided by 2^32
}

// generates a random number on (0,1)-real-interval
double genrand_real3()
{
return (((double)genrand_int32()) +
0.5)*(1.0/4294967296.0);
// divided by 2^32
}

// generates a random number on [0,1) with 53-bit
resolution
double genrand_res53()
{
uint a=genrand_int32()>>5,
b=genrand_int32()>>6;
return(a*67108864.0+b)*(1.0/9007199254740992.0);

}
// These real versions are due to Isaku Wada, 2002/01/09 added

#endregion Methods ported from C

#endregion Member Functions
}
}




And this is how to use it:


[code:1:ffb97307f8]
using System;

namespace CenterSpace.Free
{
/// <summary>
/// Simple example using the MersenneTwister class.
/// </summary>
class MersenneTwisterExample
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main(string[] args)
{
MersenneTwister randGen = new MersenneTwister();
Console.WriteLine( "100 uniform random integers in
[0,{0}]:", MersenneTwister.MaxRandomInt
);
int i;
for ( i = 0; i < 100; ++i )
{
Console.Write( "{0} ",
randGen.Next() );
if ( i%5 == 4 )
Console.WriteLine("");
}

Console.WriteLine( "100 uniform random doubles in
[0,1):" );
for ( i = 0; i < 100; ++i )
{
Console.Write( "{0} ",
randGen.NextDouble().ToString("F8") );
if ( i%5 == 4 )
Console.WriteLine("");
}
}
}
}

[/code:1:ffb97307f8]




http://www.newsfeed.com The #1 Newsgroup Service in the World! >100,000 Newsgroups
 
C

Cor

Hi Martin,

I do not think that there visists someone this newsgroup who will convert so
much code just for fun.

But here are links for language comparissing.

Code C# and VB
http://www.harding.edu/USER/fmccown/WWW/vbnet_csharp_comparison.html

Language compare
http://msdn.microsoft.com/library/en-us/vsintro7/html/vxgrfLanguageEquivalents.asp

And here some converter links maybe you can convert it first.
C# -> VB .NET Converters:

http://www.kamalpatel.net/ConvertCSharp2VB.aspx

http://csharpconverter.claritycon.com/Default.aspx

http://www.ragingsmurf.com/vbcsharpconverter.aspx

http://www.aspalliance.com/aldotnet/examples/translate.aspx

http://www.gotdotnet.com/Community/...mpleGuid=c622348b-18a9-47d6-8687-979975d5957d


http://www.remotesoft.com/ look for "Octopus"


Mostly when you have detailed difficulties there is always someone here who
will help you.

I hope this helps a little bit?

Cor
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Top