Random number generator (included): Difference between revisions

 

Note that neither LCGs nor GFSRs should be used for the most demanding applications (cryptography) without additional steps.

 

=={{header|8th}}==

* [http://vestein.arb-phys.uni-dortmund.de/~wb/RR/rrA5.html 10.5. The particular preludes and postlude - 10.5.1. The particular preludes]

¢ the next pseudo-random ℒ integral value after 'a' from a

uniformly distributed sequence on the interval [ℒ 0,ℒ maxint] ¢;

 

INT ℒ last random := # some initial random number #;

 

Note the suitable "next random number" is suggested to be: ( a := &cent; the next pseudo-random ℒ integral value after 'a' from a uniformly distributed sequence on the interval [ℒ 0,ℒ maxint] &cent;; &cent; the real value corresponding to 'a' according to some mapping of integral values [ℒ 0, ℒ max int] into real values [ℒ 0, ℒ 1) i.e., such that -0 <= x < 1 such that the sequence of real values so produced preserves the properties of pseudo-randomness and uniform distribution of the sequence of integral values &cent;);

 

For an ASCII implementation and for '''long real''' precision these routines would appears as:

INT long last random := # some initial random number #;

 

=={{header|Arturo}}==

BSD rand() produces a cycling sequence of only <math>2^{31}</math> possible states; this is already too short to produce good random numbers. The big problem with BSD rand() is that the low <math>n</math> bits' cycle sequence length is only <math>2^n</math>. (This problem happens because the modulus <math>2^{31}</math> is a power of two.) The worst case, when <math>n = 1</math>, becomes obvious if one uses the low bit to flip a coin.

 

#include <stdlib.h>

 

puts((rand() % 2) ? "heads" : "tails");

return 0;

 

If the C compiler uses BSD rand(), then this program has only two possible outputs.

Example of use:

{{works with|C++11}}

#include <string>

#include <random>

std::cout << "Random Number (hardware): " << dist(rd) << std::endl;

std::cout << "Mersenne twister (hardware seeded): " << dist(mt) << std::endl;

 

=={{header|Clojure}}==

CMake has a random ''string'' generator.

 

string(RANDOM LENGTH 4 ALPHABET 0123456789 number)

math(EXPR number "${number} + 0") # Remove extra leading 0s.

 

The current implementation (in [http://cmake.org/gitweb?p=cmake.git;a=blob;f=Source/cmStringCommand.cxx;hb=HEAD cmStringCommand.cxx] and [http://cmake.org/gitweb?p=cmake.git;a=blob;f=Source/cmSystemTools.cxx;hb=HEAD cmSystemTools.cxx]) calls [[{{PAGENAME}}#C|rand() and srand() from C]]. It picks random letters from the alphabet. The probability of each letter is near ''1 &divide; length'', but the implementation uses floating-point arithmetic to map ''RAND_MAX + 1'' values onto ''length'' letters, so there is a small modulo bias when ''RAND_MAX + 1'' is not a multiple of ''length''.

=={{header|Common Lisp}}==

The easiest way to generate random numbers in Common Lisp is to use the built-in rand function after seeding the random number generator. For example, the first line seeds the random number generator and the second line generates a number from 0 to 9

 

=={{header|D}}==

 

Based on the values given in the wikipedia entry here is a Delphi compatible implementation for use in other pascal dialects.

{$ifdef fpc}{$mode objfpc}{$endif}

end;

 

=={{header|DWScript}}==

The standard implementation, <code>[[vu]]</code>, uses a Mersenne twister.

 

 

=={{header|EchoLisp}}==

EchoLisp uses an ARC4 (or RCA4) implementation by David Bau, which replaces the JavaScript Math.random(). Thanks to him. [https://github.com/davidbau/seedrandom].

Some examples :

(random-seed "albert")

(random) → 0.9672510261922906 ; random float in [0 ... 1[

(lib 'bigint)

(random 1e200) → 48635656441292641677...3917639734865662239925...9490799697903133046309616766848265781368

 

=={{header|Elena}}==

public program()

{

console.printLine(randomGenerator.nextReal());

{{out}}

<pre>

=={{header|Elixir}}==

Elixir does not come with its own module for random number generation. But you can use the appropriate Erlang functions instead. Some examples:

# Seed the RNG

:random.seed(:erlang.now())

# Float between 0.0 and 1.0

:random.uniform()

For further information, read the Erlang section.

 

 

Seed with a fixed known value triplet A1, A2, A3:

random:seed(A1, A2, A3)

Example with the running time:

...

{A1,A2,A3} = erlang:now(),

random:seed(A1, A2, A3),

...same sequence of randoms used

Get a random float value between 0.0 and 1.0:

Rfloat = random:uniform(),

Get a random integer value between 1 and N (N is an integer >= 1):

Rint = random:uniform(N),

 

=={{header|Euler Math Toolbox}}==

Note that with the GNU gfortran compiler program needs to call random_seed with a random PUT= argument to get a pseudorandom number otherwise the sequence always starts with the same number. Intel compiler ifort reinitializes the seed randomly without PUT argument to random value using the system date and time. Here we are seeding random_seed() with some number obtained from the Linux urandom device.

 

program rosetta_random

implicit none

write(*,'(E24.16)') num

end program rosetta_random

 

=={{header|Free Pascal}}==

 

program RandomNumbers;

// Program to demonstrate the Random and Randomize functions.

Readln;

end.

 

=={{header|FreeBASIC}}==

=={{header|GAP}}==

GAP may use two algorithms : MersenneTwister, or algorithm A in section 3.2.2 of TAOCP (which is the default). One may create several ''random sources'' in parallel, or a global one (based on the TAOCP algorithm).

rs := RandomSource(IsMersenneTwister);

 

 

# Same with default random source

One can get random elements from many objects, including lists

Random([1, 10, 100]);

 

 

# Random element of Z/23Z :

 

=={{header|Go}}==

The [http://www.haskell.org/onlinereport/random.html Haskell 98 report] specifies an interface for pseudorandom number generation and requires that implementations be minimally statistically robust. It is silent, however, on the choice of algorithm.

 

Icon and Unicon both use the same linear congruential random number generator x := (x * 1103515245 + 453816694) mod 2^31. Icon uses an initial seed value of 0 and Unicon randomizes the initial seed.

 

Lua's <code>math.random()</code> is an interface to the C <code>rand()</code> function provided by the OS libc; its implementation varies by platform.

 

Mathematica 7, by default, uses an Extended Cellular Automaton method ("ExtendedCA") to generate random numbers. The main PRNG functions are <code>RandomReal[]</code> and <code>RandomInteger[]</code> You can specify alternative generation methods including the Mersenne Twister and a Linear Congruential Generator (the default earlier versions). Information about random number generation is provided at [http://reference.wolfram.com/mathematica/tutorial/RandomNumberGeneration.html#185956823 Mathematica].

 

<code>random</code> uses Richard Brent's [http://wwwmaths.anu.edu.au/~brent/random.html xorgens]. It's a member of the xorshift class of PRNGs and provides good, fast pseudorandomness (passing the BigCrush test, unlike the Mersenne twister), but it is not cryptographically strong. As implemented in PARI, its period is "at least <math>2^{4096}-1</math>".

 

random(6)+1

\\ chosen by fair dice roll.

 

=={{header|Pascal}}==

 

It uses a multiplicative congruential method:

 

=={{header|PL/SQL}}==

It will automatically initialize with the date, user ID, and process ID if no explicit initialization is performed.

If this package is seeded twice with the same seed, then accessed in the same way, it will produce the same results in both cases.

DBMS_RANDOM.VALUE --produces numbers in [0,1) with 38 digits of precision.

 

===DBMS_CRYPTO===

pseudo-random sequence of bytes, which can be used to generate random material for encryption keys.

This function is based on the RSA X9.31 PRNG (Pseudo-Random Number Generator).

DBMS_CRYPTO.RANDOMINTEGER --produces integers in the BINARY_INTEGER datatype

 

=={{header|PowerShell}}==

=={{header|Python}}==

Python uses the [[wp:Mersenne twister|Mersenne twister]] algorithm accessed via the built-in [http://docs.python.org/library/random.html random module].

 

=={{header|R}}==

 

See R help on [http://pbil.univ-lyon1.fr/library/base/html/Random.html Random number generation], or in the R system type

 

=={{header|Racket}}==

=={{header|Rascal}}==

Rascal does not have its own arbitrary number generator, but uses the [[Random_number_generator_(included)#Java | Java]] generator. Nonetheless, you can redefine the arbitrary number generator if needed. Rascal has the following functions connected to the random number generator:

arbInt(int limit); // generates an arbitrary integer below limit

arbRat(int limit, int limit); // generates an arbitrary rational number between the limits

arbReal(); // generates an arbitrary real value in the interval [0.0, 1.0]

The last function can be used to redefine the arbitrary number generator. This function is also used in the getOneFrom() functions.

ok

rascal>getOneFrom(["zebra", "elephant", "snake", "owl"]);

str: "owl"

 

=={{header|REXX}}==

<br><br>The random numbers generated are not consistent between different REXX interpreters or

<br>even the same REXX interpreters executing on different hardware.

 

The random numbers may be repeatable by specifiying a &nbsp; ''seed'' &nbsp; for the &nbsp; '''random''' &nbsp; BIF:

.

.

.

 

Comparison of '''random''' BIF output for different REXX implementations using a deterministic ''seed''.

* 08.09.2013 Walter Pachl

* Please add the output from other REXXes

If left(v,11)='REXX-ooRexx' Then

ol=ol random(-999999999,0) /* ooRexx supports negative limits */

'''outputs''' from various REXX interpreters:

<pre>

 

=={{header|Ring}}==

nr = 10

for i = 1 to nr

see random(i) + nl

next

 

=={{header|Ruby}}==

 

=={{header|Run BASIC}}==

 

=={{header|Rust}}==

=={{header|Scala}}==

Scala's <code>scala.util.Random</code> class uses a [[wp:Linear congruential generator|Linear congruential formula]] of the JVM run-time libary, as described in [http://java.sun.com/javase/6/docs/api/java/util/Random.html its documentation]. <br>An example can be found here:

 

/**

case (a, b) => println(f"$a%2d:" + "X" * b.size)

}

{{out}}

<pre> 2:XXX

Latest versions of Sidef use the Mersenne Twister algorithm to compute pseudorandom numbers, with different initial seeds (and implementations) for floating-points and integers.

 

 

=={{header|Sparkling}}==

 

Random function:

 

=={{header|TXR}}==

All '''Bourne Shell''' clones have a very quick pseudo random number generator.

 

 

Rach time $RANDOM is referenced it changes it's value (with it's maximum value 32767).

Ursala uses the [[wp:Mersenne twister|Mersenne twister]] algorithm as implemented by the [http://www.basis.uklinux.net/avram Avram] run time system for most purposes, except for arbitrary precision floating point random numbers, which are generated by the <code>urandomb</code> function from the

[http://www.mpfr.org mpfr] library.

 

=={{header|Wee Basic}}==

values modulo the argument.

 

int I;

[RanSeed(12345); \set random number generator seed to 12345

for I:= 1 to 5 do

[IntOut(0, Ran(1_000_000)); CrLf(0)];

 

Output:

=={{header|zkl}}==

zkl uses the Xorshift (http://en.wikipedia.org/wiki/Xorshift) random number generator. It will also, on occasion, read from /dev/urandom.

=={{header|ZX Spectrum Basic}}==

 

 

 

 

 

{{omit from|bc|No RNG.}}

{{omit from|dc|No RNG.}}