Anonymous user
Random number generator (included): Difference between revisions
Random number generator (included) (view source)
Revision as of 13:33, 6 October 2023
, 8 months ago→{{header|Elena}}
No edit summary |
imported>Arakov |
||
(12 intermediate revisions by 7 users not shown) | |||
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|Chapel}}==
When using the [https://chapel-lang.org/docs/modules/standard/Random.html <code>Random</code> module], Chapel defaults to a [http://www.pcg-random.org/ Permuted Linear Congruential Random Number Generator].
=={{header|Clojure}}==
Line 196 ⟶ 199:
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 208 ⟶ 211:
=={{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
<
(
[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, nor a way to use a user-specified seed.
=={{header|D}}==
Line 228 ⟶ 230:
Based on the values given in the wikipedia entry here is a Delphi compatible implementation for use in other pascal dialects.
<
unit delphicompatiblerandom;
{$ifdef fpc}{$mode objfpc}{$endif}
Line 254 ⟶ 257:
end;
end.</
=={{header|DWScript}}==
Line 262 ⟶ 265:
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 ⟶ 278:
(lib 'bigint)
(random 1e200) → 48635656441292641677...3917639734865662239925...9490799697903133046309616766848265781368
</syntaxhighlight>
=={{header|Elena}}==
ELENA
<
public program()
{
console.printLine(randomGenerator.nextReal());
console.printLine(randomGenerator.
}</
{{out}}
<pre>
Line 294 ⟶ 297:
=={{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 ⟶ 306:
# Float between 0.0 and 1.0
:random.uniform()
</syntaxhighlight>
For further information, read the Erlang section.
Line 316 ⟶ 319:
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 ⟶ 330:
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 ⟶ 351:
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 ⟶ 374:
write(*,'(E24.16)') num
end program rosetta_random
</syntaxhighlight>
=={{header|Free Pascal}}==
<
program RandomNumbers;
// Program to demonstrate the Random and Randomize functions.
Line 394 ⟶ 395:
Readln;
end.
</syntaxhighlight>
=={{header|FreeBASIC}}==
Line 453 ⟶ 454:
=={{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 ⟶ 461:
# Same with default random source
Random(1, 10);</
One can get random elements from many objects, including lists
<
Random([1, 10, 100]);
Line 469 ⟶ 470:
# Random element of Z/23Z :
Random(Integers mod 23);</
=={{header|Go}}==
Line 519 ⟶ 520:
=={{header|Lua}}==
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.
=={{header|M2000 Interpreter}}==
M2000 uses [https://en.wikipedia.org/wiki/Wichmann%E2%80%93Hill Wichmann-Hill Pseudo Random Number Generator]
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Line 589 ⟶ 593:
<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 ⟶ 635:
It uses a multiplicative congruential method:
<
random(x) = seed(x) / 2147483647</
=={{header|PL/SQL}}==
Line 641 ⟶ 645:
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 ⟶ 654:
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 ⟶ 673:
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 ⟶ 692:
(void)ranval(x);
}
}</
=={{header|R}}==
Line 716 ⟶ 720:
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 ⟶ 736:
=={{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 ⟶ 754:
<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 ⟶ 779:
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 ⟶ 799:
=={{header|Ring}}==
<
nr = 10
for i = 1 to nr
see random(i) + nl
next
</syntaxhighlight>
=={{header|Ruby}}==
Line 806 ⟶ 810:
=={{header|Run BASIC}}==
<syntaxhighlight lang
=={{header|Rust}}==
Line 815 ⟶ 819:
=={{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 ⟶ 830:
case (a, b) => println(f"$a%2d:" + "X" * b.size)
}
}</
{{out}}
<pre> 2:XXX
Line 852 ⟶ 856:
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 ⟶ 887:
Random function:
<syntaxhighlight lang
=={{header|TXR}}==
Line 892 ⟶ 896:
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 905 ⟶ 909:
[http://www.mpfr.org mpfr] library.
=={{header|V (Vlang)}}==
V (Vlang) has at least two random number modules (at the time this was typed), which are "rand" and "crypto.rand":
# https://modules.vlang.io/rand.html, in the standard library, provides two main ways in which users can generate pseudorandom numbers.
Line 926 ⟶ 930:
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 ⟶ 950:
=={{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}}==
The manual is kind enough to detail how the whole thing works. Nobody is expected to do the maths here, although it has been disassembled online; in short, it's a modified Park-Miller (or [https://en.wikipedia.org/wiki/Lehmer_random_number_generator Lehmer]) generator.
Exercises
1. Test this rule:
Suppose you choose a random number between 1 and 872 and type
<pre>RANDOMIZE your number</pre>
Then the next value of RND will be
<pre>( 75 * ( your number - 1 ) - 1 ) / 65536</pre>
2. (For mathematicians only.)
Let <math>p</math> be a (large) prime, and let <math>a</math> be a primitive root modulo <math>p</math>.
Then if <math>b_i</math> is the residue of <math>a^i</math> modulo <math>p</math> (<math>1 \leq b_i \leq p-1</math>), the sequence
<math>\frac{b_i-1}{p-1}</math>
is a cyclical sequence of <math>p-1</math> distinct numbers in the range 0 to 1 (excluding 1). By choosing <math>a</math> suitably, these can be made to look fairly random.
65537 is a Fermat prime, <math>2^{16}+1</math>. Because the multiplicative group of non-zero residues modulo 65537 has a power of 2 as its order, a residue is a primitive root if and only if it is not a quadratic residue. Use Gauss' law of quadratic reciprocity to show that 75 is a primitive root modulo 65537.
The ZX Spectrum uses <math>p</math>=65537 and <math>a</math>=75, and stores some <math>b_i-1</math> in memory. RND entails replacing <math>b_i-1</math> in memory by <math>b_{i+1}-1</math>, and yielding the result <math>(b_{i+1}-1)/(p-1)</math>. RANDOMIZE n (with 1 <math>\leq</math> n <math>\leq</math> 65535) makes <math>b_i</math> equal to n+1.
RND is approximately uniformly distributed over the range 0 to 1.
{{omit from|6502 Assembly|No RNG}}
|