Random number generator (included): Difference between revisions
m
syntax highlighting fixup automation
No edit summary |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 35:
* [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] ¢;
Line 46:
INT ℒ last random := # some initial random number #;
PROC ℒ random = ℒ REAL: ℒ next random(ℒ last random);</
Note the suitable "next random number" is suggested to be: ( a := ¢ the next pseudo-random ℒ integral value after 'a' from a uniformly distributed sequence on the interval [ℒ 0,ℒ maxint] ¢; ¢ 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 ¢);
Line 53:
For an ASCII implementation and for '''long real''' precision these routines would appears as:
<
INT long last random := # some initial random number #;
PROC long random = LONG REAL: long next random(long last random);</
=={{header|Arturo}}==
Line 113:
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>
Line 125:
puts((rand() % 2) ? "heads" : "tails");
return 0;
}</
If the C compiler uses BSD rand(), then this program has only two possible outputs.
Line 176:
Example of use:
{{works with|C++11}}
<
#include <string>
#include <random>
Line 188:
std::cout << "Random Number (hardware): " << dist(rd) << std::endl;
std::cout << "Mersenne twister (hardware seeded): " << dist(mt) << std::endl;
}</
=={{header|Clojure}}==
Line 196:
CMake has a random ''string'' generator.
<
string(RANDOM LENGTH 4 ALPHABET 0123456789 number)
math(EXPR number "${number} + 0") # Remove extra leading 0s.
message(STATUS ${number})</
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 ÷ 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''.
Line 210:
{{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
<
(rand 10)</
[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.
Line 228:
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}
Line 254:
end;
end.</
=={{header|DWScript}}==
Line 262:
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[
Line 275:
(lib 'bigint)
(random 1e200) → 48635656441292641677...3917639734865662239925...9490799697903133046309616766848265781368
</syntaxhighlight>
=={{header|Elena}}==
ELENA 4.x :
<
public program()
Line 285:
console.printLine(randomGenerator.nextReal());
console.printLine(randomGenerator.eval(0,100))
}</
{{out}}
<pre>
Line 294:
=={{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())
Line 303:
# Float between 0.0 and 1.0
:random.uniform()
</syntaxhighlight>
For further information, read the Erlang section.
Line 316:
Seed with a fixed known value triplet A1, A2, A3:
<syntaxhighlight lang="erlang">
random:seed(A1, A2, A3)
</syntaxhighlight>
Example with the running time:
<syntaxhighlight lang="erlang">
...
{A1,A2,A3} = erlang:now(),
Line 327:
random:seed(A1, A2, A3),
...same sequence of randoms used
</syntaxhighlight>
Get a random float value between 0.0 and 1.0:
<syntaxhighlight lang="erlang">
Rfloat = random:uniform(),
</syntaxhighlight>
Get a random integer value between 1 and N (N is an integer >= 1):
<syntaxhighlight lang="erlang">
Rint = random:uniform(N),
</syntaxhighlight>
=={{header|Euler Math Toolbox}}==
Line 348:
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
Line 371:
write(*,'(E24.16)') num
end program rosetta_random
</syntaxhighlight>
=={{header|Free Pascal}}==
Line 377:
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.
Line 394:
Readln;
end.
</syntaxhighlight>
=={{header|FreeBASIC}}==
Line 453:
=={{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);
Line 460:
# Same with default random source
Random(1, 10);</
One can get random elements from many objects, including lists
<
Random([1, 10, 100]);
Line 469:
# Random element of Z/23Z :
Random(Integers mod 23);</
=={{header|Go}}==
Line 589:
<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.
\\ guaranteed to the random.</
=={{header|Pascal}}==
Line 631:
It uses a multiplicative congruential method:
<
random(x) = seed(x) / 2147483647</
=={{header|PL/SQL}}==
Line 641:
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_RANDOM.NORMAL --produces normal distributed numbers with a mean of 0 and a variance of 1</
===DBMS_CRYPTO===
Line 650:
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
DBMS_CRYPTO.RANDOMNUMBER --produces integer in the NUMBER datatype in the range of [0..2**128-1]</
=={{header|PowerShell}}==
Line 669:
In case the website does not endure, the C implementation provided is:
<
typedef struct ranctx { u8 a; u8 b; u8 c; u8 d; } ranctx;
Line 688:
(void)ranval(x);
}
}</
=={{header|R}}==
Line 716:
See R help on [http://pbil.univ-lyon1.fr/library/base/html/Random.html Random number generation], or in the R system type
<
help.search("Distribution", package="stats")</
=={{header|Racket}}==
Line 732:
=={{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]
arbSeed(int seed);</
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"
</syntaxhighlight>
=={{header|REXX}}==
Line 750:
<br><br>The random numbers generated are not consistent between different REXX interpreters or
<br>even the same REXX interpreters executing on different hardware.
<
y = random(100, 200)</
The random numbers may be repeatable by specifiying a ''seed'' for the '''random''' BIF:
<
.
.
.
y = random(100, 200)</
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
Line 775:
If left(v,11)='REXX-ooRexx' Then
ol=ol random(-999999999,0) /* ooRexx supports negative limits */
Say ol</
'''outputs''' from various REXX interpreters:
<pre>
Line 795:
=={{header|Ring}}==
<
nr = 10
for i = 1 to nr
see random(i) + nl
next
</syntaxhighlight>
=={{header|Ruby}}==
Line 806:
=={{header|Run BASIC}}==
<syntaxhighlight lang
=={{header|Rust}}==
Line 815:
=={{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:
<
/**
Line 826:
case (a, b) => println(f"$a%2d:" + "X" * b.size)
}
}</
{{out}}
<pre> 2:XXX
Line 852:
Latest versions of Sidef use the Mersenne Twister algorithm to compute pseudorandom numbers, with different initial seeds (and implementations) for floating-points and integers.
<
say 100.irand # random integer in the interval [0,100)</
=={{header|Sparkling}}==
Line 883:
Random function:
<syntaxhighlight lang
=={{header|TXR}}==
Line 892:
All '''Bourne Shell''' clones have a very quick pseudo random number generator.
<syntaxhighlight lang
Rach time $RANDOM is referenced it changes it's value (with it's maximum value 32767).
Line 926:
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:
Line 946:
=={{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.
<syntaxhighlight lang
=={{header|ZX Spectrum Basic}}==
|