Random Number Generators in IronPython QuickStart Sample

Illustrates how to use specialized random number generator classes in the Numerics.NET.Statistics.Random namespace in IronPython.

This sample is also available in: C#, Visual Basic, F#.

Overview

This QuickStart sample demonstrates how to use the various random number generator classes available in Numerics.NET. These classes provide alternatives to the standard System.Random class with additional features and different algorithms.

The sample covers three main random number generator types:

  • The ExtendedRandom class which enhances System.Random with additional functionality like filling arrays
  • The RANLUX generators which offer different “luxury levels” of random number quality
  • The Generalized Feedback Shift Register (GFSR) generator
  • The Mersenne Twister, a variant of GFSR that is widely used in scientific computing

For each generator type, the sample shows how to:

  • Create instances with different constructors and parameters
  • Generate random integers and floating point numbers
  • Fill arrays with random values
  • Select appropriate luxury levels for RANLUX generators

The sample also mentions that all generators can produce random variates from arbitrary probability distributions, with a reference to the NonUniformRandomNumbers sample for details.

The code

import numerics

from System import Array

from Extreme.Statistics.Random import *
from Extreme.Mathematics.LinearAlgebra import *

# Illustrates the use of the classes that implement
# pseudo-random number generators.

# This QuickStart Sample gives an overview of the pseudo-random
# number generators that provide an alternative for the
# System.Random class..

#
# ExtendedRandom class
#

# The ExtendedRandom class simply extends the functionality
# of the System.Random class:
extended = ExtendedRandom()
intValues = Array.CreateInstance(int, 100)
doubleValues = Array.CreateInstance(float, 100)

# The fill method fills an array of integers with random numbers
extended.Fill(intValues)
print "integer(99) =", intValues[99]

# Or, it can generate uniform real values:
extended.Fill(doubleValues)
print "double(99) =", doubleValues[99]

# All random number generators can also produce variates 
# from any user-specified probability distribution.
# The NonUniformRandomNumbers sample illustrates 
# how to do this.


#
# RANLUX Generators
#

# The RANLUX generators are available with three different 
# 'luxury levels.' Each level produces random numbers of 
# increasing quality at a performance cost.
#
# There are four constructors. The first constructor uses the
# default seed and the default (lowest) luxury level:
ranLux1 = RanLux()

# We can specify a seed value as well:
ranLux2 = RanLux(99)

# We can specify the luxury level in the constructor:
ranLux3 = RanLux(RanLuxLuxuryLevel.Better)

# Finally, we can specify both a seed and the luxury level:
ranLux4 = RanLux(99, RanLuxLuxuryLevel.Best)

# All methods of System.Random and ExtendedRandom are available:
ranLux1.Fill(intValues)
ranLux2.Fill(doubleValues)
print "Integer from RanLux(Best):", ranLux3.Next(100)


#
# Generalized Feedback Shift Register Generator
#

# This generator is implemented by the GfsrGenerator class.
# It has three constructors. A default constructor that uses
# a default seed value:
gfsr1 = GfsrGenerator()

# A constructor that takes a single integer seed:
gfsr2 = GfsrGenerator(99)

# And a constructor that takes an array of integers
# as its seed. The maximum size of this seed array
# is 2^14-1 = 16383.
gfsr3 = GfsrGenerator(Array[int]([ 99, 17, int.MaxValue ]))

# Once again, all standard methods are available.
print "Double from GFSR:", gfsr2.NextDouble()

#
# Mersenne Twister
#

# The Mersenne Twister is a variation on the GFSR generator and, # not surprisingly, also has three constructors:
mersenne1 = MersenneTwister()
mersenne2 = MersenneTwister(99)
mersenne3 = MersenneTwister(Array[int] ([ 99, 17, int.MaxValue ]))