Random number generator (included): Difference between revisions

* [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''.

{{incorrect|Common Lisp|Use CLHS as reference. Function rand is incorrect it should be random .}}

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

[https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node133.html Common Lisp: The Language, 2nd Ed.] does not specify a specific random number generator algorithm.

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}}==

ELENA 4.x :

public program()

console.printLine(randomGenerator.nextReal());

console.printLine(randomGenerator.eval(0,100))

{{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}}==

The random is conform MT19937 and is therefor compatible with e.g. the C++11 MT19937 implementation.

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}}==

<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}}==

In case the website does not endure, the C implementation provided is:

typedef struct ranctx { u8 a; u8 b; u8 c; u8 d; } ranctx;

(void)ranval(x);

}

=={{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).

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|Z80 Assembly}}==

This is a bit of a stretch, but the R register which handles memory refresh can be read from to obtain somewhat random numbers. It only ranges from 0 to 127 and is most likely to be very biased but this is as close to a built-in RNG as the language has.

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