This package contains various pseudo random number generators. A
random number generator is a package that consists of the following
elements:
 Integer nState is a constant that defines the
length of the internal state vector (in order that an appropriate
Integer vector of this length can be declared, depending on the
selected random number generator).
 Function initialState(..) is used to
initialize the state of the random number generator by providing
Integer seeds and calling the random number generator often enough
that statistically relevant random numbers are returned by every
call of function random(..).
 Function random(..) is used to return a random
number of type Real in the range 0.0 < random ≤ 1.0 for every
call. Furthermore, the updated (internal) state of the random
number generator is returned as well.
The Generators package contains the xorshift
suite of random number generators from Sebastiano Vigna (from 2014;
based on work of George Marsaglia). The properties of these random
number generators are summarized below and compared with the often
used Mersenne Twister (MT1993764) generator. The table is based on
http://xorshift.di.unimi.it/ and
on the articles:
Sebastiano Vigna: An experimental
exploration of Marsaglia's xorshift generators, scrambled,
2014.
Sebastiano Vigna: Further
scramblings of Marsaglia's xorshift generators, 2014.
Summary of the properties of the random number generators:
Property 
xorshift64* 
xorshift128+ 
xorshift1024* 
MT1993764 
Period 
2^64 
2^128 
2^1024 
2^19937 
Length of state (# 32 bit integer) 
2 
4 
33 
624 
Statistic failures (Big Crush) 
363 
64 
51 
516 
Systematic failures (Big Crush) 
yes 
no 
no 
yes 
Worst case startup 
> 1 call 
> 20 calls 
> 100 calls 
> 100000 calls 
Run time (MT=1.0) 
0.39 
0.27 
0.33 
1.0 
Further explanations of the properties above:
 The period defines the number of random
numbers generated before the sequence begins to repeat itself.
According to "A long period
does not imply high quality" a period of 2^1024 is by far large
enough for even massively parallel simulations with huge number of
random number computations per simulation. A period of 2^128 might
be not enough for massively parallel simulations.
 Length of state (# 32 bit integer) defines the
number of "int" (that is Modelica Integer) elements used for the
internal state vector.
 Big Crush is part of TestU01 a
huge framework for testing random number generators. According to
these tests, the statistical properties of the xorshift random
number generators are better than the ones of the Mersenne Twister
random number generator.
 Worst case startup means how many calls are
needed until getting from a bad seed to random numbers with
appropriate statistical properties. Here, the xorshift random
number suite has much better properties than the Mersenne Twister.
When initializing a random number generator, the above property is
taken into account and appropriate random numbers are generated, so
that a subsequent call of random(..) will generate statistically
relevant random numbers, even if the user provides a bad initial
seed (such as localSeed=1). This means, any Integer number can be
given as initial seed without influencing the quality of the
generated random numbers.
 Run time shows that the xorshift random number
generators are all much faster than the Mersenne Twister random
number generator, although this is not really relevant for most
simulations, because the execution time of the other parts of the
simulations is usually much larger.
The xorshift random number generators are used in the following
way in the Blocks.Noise package:
 Xorshift64star (xorshift64*) is used to generate the initial
internal state vectors of the other generators from two Integer
values, due to the very good startup properties.
 Xorshift128plus (xorshift128+) is the random number generator
used by the blocks in Blocks.Noise. Since these
blocks hold the internal state vector for every block instance, and
the internal state vector is copied whenever a new random number is
drawn, it is important that the internal state vector is short (and
still has good statistical properties as shown in the table
above).
 Xorshift1024star (xorshift1024*) is the basis of the impure
function Math.Random.Utilities.impureRandom
which in turn is used with Blocks.Noise.GlobalSeed.
The internal state vector is not exposed. It is updated internally,
whenever a new random number is drawn.
Note, the generators produce 64 bit random numbers. These
numbers are mapped to the 52 bit mantissa of double numbers in the
range 0.0 .. 1.0.
Contents
Date 
Description 
June 22, 2015 

Generated at 20200330T01:39:08Z by OpenModelicaOpenModelica
1.16.0~dev257g14ef94c using GenerateDoc.mos