# Unpredictable Numbers That Are Distributed Over a Certain Range Are

Unpredictable Numbers That Are Distributed Over a Certain Range Are.

Producing a sequence that cannot exist predicted better than by random chance

Dice are an example of a mechanical hardware random number generator. When a cubical die is rolled, a random number from 1 to 6 is obtained.

Random number generation
is a process by which, ofttimes by means of a
random number generator
(RNG), a sequence of numbers or symbols that cannot exist reasonably predicted better than by random chance is generated. This means that the particular issue sequence volition contain some patterns detectable in hindsight but unpredictable to foresight. Truthful random number generators tin exist
hardware random-number generators
(HRNGS) that generate random numbers, wherein each generation is a function of the electric current value of a physical environs’south attribute that is constantly changing in a style that is practically impossible to model. This would be in dissimilarity to so-called “random number generations” done by
pseudorandom number generators
(PRNGs) that generate numbers that only await random but are in fact pre-adamant—these generations can be reproduced simply by knowing the state of the PRNG.

Various applications of randomness accept led to the development of several different methods for generating random information. Some of these have existed since ancient times, amongst whose ranks are well-known “classic” examples, including the rolling of dice, coin flipping, the shuffling of playing cards, the apply of yarrow stalks (for divination) in the I Ching, as well every bit endless other techniques. Because of the mechanical nature of these techniques, generating large quantities of sufficiently random numbers (important in statistics) required much work and time. Thus, results would sometimes be collected and distributed as random number tables.

Several computational methods for pseudorandom number generation exist. All fall curt of the goal of true randomness, although they may meet, with varying success, some of the statistical tests for randomness intended to measure how unpredictable their results are (that is, to what degree their patterns are discernible). This generally makes them unusable for applications such as cryptography. Nonetheless, advisedly designed
cryptographically secure pseudorandom number generators
(CSPRNGS) likewise be, with special features specifically designed for apply in cryptography.

Contents

## Practical applications and uses

Random number generators have applications in gambling, statistical sampling, computer simulation, cryptography, completely randomized design, and other areas where producing an unpredictable result is desirable. Mostly, in applications having unpredictability as the paramount feature, such every bit in security applications, hardware generators are mostly preferred over pseudorandom algorithms, where feasible.

Pseudorandom number generators are very useful in developing Monte Carlo-method simulations, as debugging is facilitated by the ability to run the aforementioned sequence of random numbers again by starting from the aforementioned
random seed. They are also used in cryptography – then long as the
seed
is secret. Sender and receiver can generate the same set of numbers automatically to utilize as keys.

The generation of pseudorandom numbers is an important and common job in computer programming. While cryptography and certain numerical algorithms crave a very high degree of
credible
randomness, many other operations merely demand a pocket-size amount of unpredictability. Some simple examples might be presenting a user with a “random quote of the twenty-four hours”, or determining which fashion a reckoner-controlled adversary might move in a computer game. Weaker forms of
randomness
are used in hash algorithms and in creating amortized searching and sorting algorithms.

Some applications which appear at first sight to exist suitable for randomization are in fact not quite so unproblematic. For example, a system that “randomly” selects music tracks for a background music system must only
appear
random, and may even have means to control the selection of music: a true random organisation would accept no restriction on the same detail appearing 2 or three times in succession.

## “Truthful” vs. pseudo-random numbers

There are two principal methods used to generate random numbers. The offset method measures some physical phenomenon that is expected to exist random and then compensates for possible biases in the measurement procedure. Example sources include measuring atmospheric racket, thermal noise, and other external electromagnetic and quantum phenomena. For example, cosmic groundwork radiations or radioactivity as measured over short timescales represent sources of natural entropy.

The speed at which entropy tin exist obtained from natural sources is dependent on the underlying concrete phenomena being measured. Thus, sources of naturally occurring “true” entropy are said to be blocking – they are charge per unit-limited until enough entropy is harvested to meet the demand. On some Unix-like systems, including about Linux distributions, the pseudo device file
/dev/random
will block until sufficient entropy is harvested from the environment.[1]
Due to this blocking behavior, big majority reads from
/dev/random, such as filling a hd drive with random bits, can often be slow on systems that use this type of entropy source.

The second method uses computational algorithms that can produce long sequences of apparently random results, which are in fact completely adamant by a shorter initial value, known as a seed value or fundamental. As a result, the entire seemingly random sequence tin can exist reproduced if the seed value is known. This type of random number generator is ofttimes called a pseudorandom number generator. This type of generator typically does not rely on sources of naturally occurring entropy, though information technology may be periodically seeded past natural sources. This generator type is non-blocking, so they are not rate-limited past an external event, making big bulk reads a possibility.

Some systems take a hybrid approach, providing randomness harvested from natural sources when available, and falling dorsum to periodically re-seeded software-based cryptographically secure pseudorandom number generators (CSPRNGs). The fallback occurs when the desired read rate of randomness exceeds the power of the natural harvesting approach to keep upwards with the demand. This approach avoids the rate-limited blocking behavior of random number generators based on slower and purely ecology methods.

While a pseudorandom number generator based solely on deterministic logic can never exist regarded equally a “true” random number source in the purest sense of the word, in do they are generally sufficient even for demanding security-critical applications. Carefully designed and implemented pseudorandom number generators tin be certified for security-disquisitional cryptographic purposes, every bit is the case with the yarrow algorithm and fortuna. The erstwhile is the basis of the
/dev/random
source of entropy on FreeBSD, AIX, OS X, NetBSD, and others. OpenBSD uses a pseudorandom number algorithm known as arc4random.[2]

## Generation methods

### Physical methods

The primeval methods for generating random numbers, such as dice, coin flipping and roulette wheels, are still used today, mainly in games and gambling as they tend to be too slow for nigh applications in statistics and cryptography.

A concrete random number generator can exist based on an essentially random diminutive or subatomic physical phenomenon whose unpredictability can be traced to the laws of quantum mechanics. Sources of entropy include radioactivity, thermal noise, shot noise, avalanche noise in Zener diodes, clock drift, the timing of bodily movements of a difficult disk read-write caput, and radio noise. However, physical phenomena and tools used to measure them generally feature asymmetries and systematic biases that make their outcomes not uniformly random. A randomness extractor, such as a cryptographic hash function, can be used to approach a compatible distribution of \$.25 from a not-uniformly random source, though at a lower flake charge per unit.

The appearance of wideband photonic entropy sources, such every bit optical chaos and amplified spontaneous emission noise, greatly aid the development of the concrete random number generator. Among them, optical chaos[3]
[4]
has a high potential to physically produce high-speed random numbers due to its high bandwidth and large amplitude. A prototype of a high speed, real-fourth dimension physical random bit generator based on a chaotic light amplification by stimulated emission of radiation was built in 2013.[5]

Diverse imaginative ways of collecting this entropic information have been devised. One technique is to run a hash function against a frame of a video stream from an unpredictable source. Lavarand used this technique with images of a number of lava lamps. HotBits measures radioactive decay with Geiger–Muller tubes,[6]
while Random.org uses variations in the aamplitude of atmospheric dissonance recorded with a normal radio.

Sit-in of a simple random number generator based on where and when a push is clicked

Another common entropy source is the behavior of human users of the arrangement. While people are non considered practiced randomness generators upon request, they generate random beliefs quite well in the context of playing mixed strategy games.[7]
Some security-related computer software requires the user to make a lengthy series of mouse movements or keyboard inputs to create sufficient entropy needed to generate random keys or to initialize pseudorandom number generators.[viii]

### Computational methods

Most computer generated random numbers use PRNGs which are algorithms that can automatically create long runs of numbers with adept random backdrop simply eventually the sequence repeats (or the memory usage grows without bound). These random numbers are fine in many situations but are not as random every bit numbers generated from electromagnetic atmospheric noise used as a source of entropy.[ix]
The series of values generated by such algorithms is by and large adamant by a fixed number called a
seed. Ane of the virtually common PRNG is the linear congruential generator, which uses the recurrence

${\displaystyle X_{n+1}=(aX_{n}+b)\,{\textrm {mod}}\,m}$

X

north
+
1

=
(
a

X

n

+
b
)

modernistic

m

{\displaystyle X_{n+i}=(aX_{due north}+b)\,{\textrm {mod}}\,m}

to generate numbers, where
a,
b
and
g
are large integers, and

${\displaystyle X_{n+1}}$

X

n
+
ane

{\displaystyle X_{n+1}}

X
as a series of pseudorandom numbers. The maximum number of numbers the formula can produce is the modulus,
m. The recurrence relation tin can be extended to matrices to have much longer periods and better statistical properties .[ten]
To avoid certain not-random backdrop of a single linear congruential generator, several such random number generators with slightly dissimilar values of the multiplier coefficient,
a, tin can be used in parallel, with a “master” random number generator that selects from amidst the several different generators.[
citation needed
]

A simple pen-and-newspaper method for generating random numbers is the so-called centre-foursquare method suggested by John von Neumann. While simple to implement, its output is of poor quality. It has a very brusk period and severe weaknesses, such every bit the output sequence nearly always converging to nothing. A recent innovation is to combine the centre foursquare with a Weyl sequence. This method produces high quality output through a long menses.[11]

Most computer programming languages include functions or library routines that provide random number generators. They are ofttimes designed to provide a random byte or give-and-take, or a floating bespeak number uniformly distributed between 0 and 1.

The quality i.eastward. randomness of such library functions varies widely from completely predictable output, to cryptographically secure. The default random number generator in many languages, including Python, Ruddy, R, IDL and PHP is based on the Mersenne Twister algorithm and is
non
sufficient for cryptography purposes, as is explicitly stated in the language documentation. Such library functions often have poor statistical properties and some will echo patterns later on only tens of thousands of trials. They are ofttimes initialized using a computer’s real time clock every bit the seed, since such a clock is 64 bit and measures in nanoseconds, far beyond the person’s precision. These functions may provide enough randomness for certain tasks (for example video games) but are unsuitable where loftier-quality randomness is required, such as in cryptography applications, statistics or numerical analysis.[
commendation needed
]

Much higher quality random number sources are available on near operating systems; for example /dev/random on various BSD flavors, Linux, Mac OS 10, IRIX, and Solaris, or CryptGenRandom for Microsoft Windows. Nigh programming languages, including those mentioned higher up, provide a ways to access these higher quality sources.

### By humans

Random number generation may also exist performed by humans, in the form of collecting various inputs from end users and using them equally a randomization source. However, almost studies find that human subjects have some caste of non-randomness when attempting to produce a random sequence of e.g. digits or letters. They may alternating likewise much between choices when compared to a skillful random generator;[12]
thus, this approach is not widely used.

## Mail service-processing and statistical checks

Even given a source of plausible random numbers (perhaps from a breakthrough mechanically based hardware generator), obtaining numbers which are completely unbiased takes care. In improver, behavior of these generators often changes with temperature, power supply voltage, the historic period of the device, or other outside interference. And a software issues in a pseudorandom number routine, or a hardware bug in the hardware it runs on, may exist similarly difficult to find.

Generated random numbers are sometimes subjected to statistical tests before use to ensure that the underlying source is still working, and and so post-processed to amend their statistical properties. An instance would be the TRNG9803[13]
hardware random number generator, which uses an entropy measurement as a hardware test, and and then postal service-processes the random sequence with a shift annals stream zippo. It is generally hard to use statistical tests to validate the generated random numbers. Wang and Nicol[xiv]
proposed a distance-based statistical testing technique that is used to identify the weaknesses of several random generators. Li and Wang[15]
proposed a method of testing random numbers based on laser cluttered entropy sources using Brownian move properties.

## Other considerations

### Reshaping the distribution

#### Compatible distributions

Well-nigh random number generators natively work with integers or private bits, and then an extra step is required to arrive at the “canonical” uniform distribution betwixt 0 and 1. The implementation is not as niggling equally dividing the integer by its maximum possible value. Specifically:[16]
[17]

1. The integer used in the transformation must provide enough \$.25 for the intended precision.
2. The nature of floating-point math itself means there exists more precision the closer the number is to zip. This actress precision is usually not used due to the sheer number of bits required.
3. Rounding error in sectionalisation may bias the result. At worst, a supposedly excluded spring may be drawn countrary to expectations based on real-number math.

The mainstream algorithm, used by OpenJDK, Rust, and NumPy, is described in a proposal for C++’due south STL. It does not utilise the extra precision and suffers from bias only in the last bit due to round-to-even.[18]
Other numeric concerns are warranted when shifting this “canonical” uniform distribution to a different range.[19]
A proposed method for the Swift programming language claims to utilise the full precision everywhere.[20]

Uniformly distributed integers are commonly used in algorithms such every bit the Fisher–Yates shuffle. Again, a naive implementation may induce a modulo bias into the result, so more involved algorithms must be used. A method that nearly never performs division was described in 2018 by Daniel Lemire,[21]
with the current state-of-the-art beingness the arithmetic encoding-inspired 2021 “optimal algorithm” by Stephen Canon of Apple tree Inc.[22]

Most 0 to 1 RNGs include 0 but exclude ane, while others include or exclude both.

#### Other distributions

Given a source of uniform random numbers, at that place are a couple of methods to create a new random source that corresponds to a probability density part. One method, called the inversion method, involves integrating up to an area greater than or equal to the random number (which should be generated between 0 and 1 for proper distributions). A 2nd method, called the acceptance-rejection method, involves choosing an 10 and y value and testing whether the office of 10 is greater than the y value. If it is, the x value is accepted. Otherwise, the x value is rejected and the algorithm tries over again.[23]
[24]

As an example for rejection sampling, to generate a pair of statistically independent standard ordinarily distributed random numbers (x,
y), ane may first generate the polar coordinates (r,
θ), where
r
2two
ii
and
θ~UNIFORM(0,2π) (see Box–Muller transform).

### Whitening

The outputs of multiple contained RNGs tin be combined (for example, using a bit-wise XOR operation) to provide a combined RNG at least as proficient equally the all-time RNG used. This is referred to as software whitening.

Computational and hardware random number generators are sometimes combined to reflect the benefits of both kinds. Computational random number generators can typically generate pseudorandom numbers much faster than physical generators, while physical generators can generate “truthful randomness.”

## Depression-discrepancy sequences as an culling

Some computations making utilise of a random number generator tin can be summarized as the computation of a total or boilerplate value, such as the computation of integrals by the Monte Carlo method. For such problems, it may be possible to discover a more accurate solution by the employ of so-called low-discrepancy sequences, also called quasirandom numbers. Such sequences have a definite pattern that fills in gaps evenly, qualitatively speaking; a truly random sequence may, and ordinarily does, leave larger gaps.

## Activities and demonstrations

The post-obit sites make bachelor random number samples:

• The SOCR resource pages comprise a number of hands-on interactive activities and demonstrations of random number generation using Java applets.
• The Quantum Optics Grouping at the ANU generates random numbers sourced from breakthrough vacuum. Sample of random numbers are bachelor at their quantum random number generator inquiry page.
• Random.org makes bachelor random numbers that are sourced from the randomness of atmospheric noise.
• The Breakthrough Random Flake Generator Service at the Ruđer Bošković Institute harvests randomness from the quantum process of photonic emission in semiconductors. They supply a multifariousness of ways of fetching the information, including libraries for several programming languages.
• The Grouping at the Taiyuan University of Technology generates random numbers sourced from a chaotic laser. Samples of random number are available at their Physical Random Number Generator Service.

## Backdoors

Since much cryptography depends on a cryptographically secure random number generator for key and cryptographic nonce generation, if a random number generator tin exist made predictable, it can be used equally backdoor by an attacker to break the encryption.

The NSA is reported to have inserted a backdoor into the NIST certified cryptographically secure pseudorandom number generator Dual EC DRBG. If for example an SSL connectedness is created using this random number generator, then according to Matthew Green it would allow NSA to decide the state of the random number generator, and thereby eventually be able to read all data sent over the SSL connexion.[25]
Even though information technology was apparent that Dual_EC_DRBG was a very poor and peradventure backdoored pseudorandom number generator long before the NSA backdoor was confirmed in 2013, it had seen significant usage in exercise until 2013, for case by the prominent security visitor RSA Security.[26]
There have subsequently been accusations that RSA Security knowingly inserted a NSA backdoor into its products, perhaps as part of the Bullrun plan. RSA has denied knowingly inserting a backdoor into its products.[27]

It has too been theorized that hardware RNGs could be secretly modified to have less entropy than stated, which would make encryption using the hardware RNG susceptible to assault. One such method which has been published works past modifying the dopant mask of the flake, which would be undetectable to optical contrary-engineering science.[28]
For case, for random number generation in Linux, it is seen as unacceptable to use Intel’south RDRAND hardware RNG without mixing in the RDRAND output with other sources of entropy to counteract any backdoors in the hardware RNG, especially after the revelation of the NSA Bullrun programme.[29]
[thirty]

In 2010, a U.S. lottery draw was rigged by the information security director of the Multi-State Lottery Association (MUSL), who surreptitiously installed backdoor malware on the MUSL’s secure RNG computer during routine maintenance.[31]
During the hacks the man won a total corporeality of \$16,500,000 by predicting the numbers correctly a few times in twelvemonth.

Address space layout randomization (ASLR), a mitigation against rowhammer and related attacks on the concrete hardware of memory chips has been plant to be inadequate every bit of early 2017 past VUSec. The random number algorithm, if based on a shift annals implemented in hardware, is predictable at sufficiently big values of p and tin can be reverse engineered with enough processing power (Brute Strength Hack). This also indirectly means that malware using this method can run on both GPUs and CPUs if coded to do then, even using GPU to suspension ASLR on the CPU itself.[32]

• Flipism
• League of entropy
• Listing of random number generators
• PP (complexity)
• Procedural generation
• Randomized algorithm
• Random countersign generator
• Random variable, contains a take chances-dependent value

## References

1. ^

`random(four)`
– Linux Developer’s Transmission – Special Files

2. ^

`arc4random(three)`
– OpenBSD Library Functions Manual

3. ^

Li, Pu; Wang, Yun-Cai; Zhang, Jian-Zhong (2010-09-xiii). “All-optical fast random number generator”.
Optics Limited.
18
(19): 20360–20369. Bibcode:2010OExpr..1820360L. doi:10.1364/OE.18.020360. ISSN 1094-4087. PMID 20940928.

4. ^

Li, Pu; Lord’s day, Yuanyuan; Liu, Xianglian; Yi, Xiaogang; Zhang, Jianguo; Guo, Xiaomin; Guo, Yanqiang; Wang, Yuncai (2016-07-15). “Fully photonics-based physical random scrap generator”.
Optics Letters.
41
(fourteen): 3347–3350. Bibcode:2016OptL…41.3347L. doi:10.1364/OL.41.003347. ISSN 1539-4794. PMID 27420532. S2CID 2909061.

5. ^

Wang, Anbang; Li, Pu; Zhang, Jianguo; Zhang, Jianzhong; Li, Lei; Wang, Yuncai (2013-08-26). “4.5 Gbps high-speed real-time physical random bit generator”.
Optics Express.
21
(17): 20452–20462. Bibcode:2013OExpr..2120452W. doi:10.1364/OE.21.020452. ISSN 1094-4087. PMID 24105589. S2CID 10397141.

6. ^

Walker, John. “HotBits: Genuine Random Numbers”. Retrieved
2009-06-27
.

7. ^

Halprin, Ran; Naor, Moni. “Games for Extracting Randomness”
(PDF). Department of Computer Science and Applied Mathematics, Weizmann Institute of Scientific discipline. Retrieved
2009-06-27
.

[
]

8. ^

TrueCrypt Foundation. “TrueCrypt Beginner’s Tutorial, Role three”. Retrieved
2009-06-27
.

9. ^

“RANDOM.ORG – True Random Number Service”.
world wide web.random.org
. Retrieved
2016-01-14
.

10. ^

“High Dimensionality Pseudo Random Number Generators”. Retrieved
2018-11-21
.

11. ^

Widynski, Bernard (19 May 2020). “Middle-Square Weyl Sequence RNG”. arXiv:1704.00358
[cs.CR].

12. ^

West. A. Wagenaar (1972). “Generation of random sequences by homo subjects: a critical survey of the literature”.
Psychological Bulletin.
77
(ane): 65–72. CiteSeerX10.1.ane.211.9085. doi:ten.1037/h0032060.

13. ^

Dömstedt, B. (2009). “TRNG9803 Truthful Random Number Generator”. Manufacturer: www.TRNG98.se.

14. ^

Wang, Yongge (2014). “Statistical Properties of Pseudo Random Sequences and Experiments with PHP and Debian OpenSSL”.
Computer Security – ESORICS 2014. Lecture Notes in Calculator Science. Vol. 8712. Heidelberg: Springer LNCS. pp. 454–471. doi:10.1007/978-three-319-11203-9_26. ISBN978-3-319-11202-two.

15. ^

Li, Pu; Yi, Xiaogang; Liu, Xianglian; Wang, Yuncai; Wang, Yongge (2016-07-11). “Brownian move properties of optoelectronic random fleck generators based on light amplification by stimulated emission of radiation anarchy”.
Optics Express.
24
(14): 15822–15833. Bibcode:2016OExpr..2415822L. doi:10.1364/OE.24.015822. ISSN 1094-4087. PMID 27410852.

16. ^

Goualard, F. (2020). “Generating Random Floating-Point Numbers by Dividing Integers: A Example Report”.
Computational Science – ICCS 2020. ICCS. Lecture Notes in Information science. Vol. 12138. pp. 15–28. doi:10.1007/978-3-030-50417-5_2. ISBN978-three-030-50416-8. S2CID 219889587.

17. ^

Campbell, Taylor R. (2014). “Uniform random floats: How to generate a double-precision floating-point number in [0, 1] uniformly at random given a uniform random source of bits”. Retrieved
iv September
2021
.

18. ^

“A new specification for std::generate_canonical”.
www.open up-std.org.

19. ^

Goualard, Frédéric (July 2021). “Drawing random floating-bespeak numbers from an interval”.
HAL
. Retrieved
iv September
2021
.

20. ^

NevinBR. “[stdlib] Floating-signal random-number improvements past NevinBR · Pull Request #33560 · apple/swift”.
GitHub.

21. ^

Lemire, Daniel (23 February 2019). “Fast Random Integer Generation in an Interval”.
ACM Transactions on Modeling and Computer Simulation.
29
(ane): 1–12. arXiv:1805.10941. doi:10.1145/3230636. S2CID 44061046.

22. ^

“An optimal algorithm for divisional random integers by stephentyrone · Pull Request #39143 · apple/swift”.
GitHub.

23. ^

The MathWorks. “Common generation methods”. Retrieved
2011-10-13
.

24. ^

The Numerical Algorithms Group. “G05 – Random Number Generators”
(PDF).
NAG Library Manual, Mark 23
. Retrieved
2012-02-09
.

25. ^

matthew Green (2013-09-xviii). “The Many Flaws of Dual_EC_DRBG”.

26. ^

Matthew Greenish (2013-09-20). “RSA warns developers not to use RSA products”.

27. ^

“We don’t enable backdoors in our crypto products, RSA tells customers”.
Ars Technica. 2013-09-20.

28. ^

“Researchers can sideslip an undetectable trojan into Intel’south Ivy Span CPUs”.
Ars Technica. 2013-09-xviii.

29. ^

Theodore Ts’o. “I am and then glad I resisted pressure from Intel engineers to let /dev/random rely only on the RDRAND pedagogy”. Google Plus.

30. ^

Theodore Ts’o. “Re: [PATCH] /dev/random: Bereft of entropy on many architectures”. LWN.

31. ^

Nestel, G.Fifty. (July seven, 2015). “Inside the Biggest Lottery Scam Ever”.
The Daily Animate being
. Retrieved
July 10,
2015
.

32. ^

“AnC – VUSec”. Retrieved
13 July
2018
.

• Donald Knuth (1997). “Chapter 3 – Random Numbers”.
The Art of Estimator Programming. Vol. ii: Seminumerical algorithms (3 ed.).

• Fifty’Ecuyer, Pierre (2017). “History of Uniform Random Number Generation”
(PDF).
Proceedings of the 2017 Winter Simulation Conference. IEEE Printing. pp. 202–230.

• L’Ecuyer, Pierre (2012). “Random Number Generation”
(PDF). In J. E. Gentle; W. Haerdle; Y. Mori (eds.).
Handbook of Computational Statistics: Concepts and Methods.
Handbook of Computational Statistics
(second ed.). Springer-Verlag. pp. 35–71. doi:10.1007/978-3-642-21551-3_3. hdl:10419/22195. ISBN978-3-642-21550-half-dozen.

• Kroese, D. P.; Taimre, T.; Botev, Z.I. (2011). “Affiliate 1 – Compatible Random Number Generation”.
Handbook of Monte Carlo Methods. New York: John Wiley & Sons. p. 772. ISBN978-0-470-17793-8.

• Press, WH; Teukolsky, SA; Vetterling, WT; Flannery, BP (2007). “Chapter 7. Random Numbers”.
Numerical Recipes: The Fine art of Scientific Computing
(third ed.). New York: Cambridge University Printing. ISBN978-0-521-88068-8.

• NIST SP800-90A, B, C serial on random number generation
• M. Tomassini, M. Sipper, and M. Perrenoud (October 2000). “On the generation of high-quality random numbers by two-dimensional cellular automata”.
IEEE Transactions on Computers.
49
(ten): 1146–1151. doi:x.1109/12.888056.

`{{cite journal}}`: CS1 maint: uses authors parameter (link)
• RANDOM.ORG True Random Number Service
• Quantum random number generator at ANU
• Random and Pseudorandom on
In Our Time
at the BBC
• jRand a Coffee-based framework for the generation of simulation sequences, including pseudorandom sequences of numbers
• Random number generators in NAG Fortran Library
• Randomness Beacon at NIST, broadcasting full-entropy fleck-strings in blocks of 512 \$.25 every threescore seconds. Designed to provide unpredictability, autonomy, and consistency.
• A system telephone call for random numbers: getrandom(), a LWN.net commodity describing a dedicated Linux organization telephone call
• Statistical Properties of Pseudo Random Sequences and Experiments with PHP and Debian OpenSSL
• Random Sequence Generator based on Barrage Racket

## Unpredictable Numbers That Are Distributed Over a Certain Range Are

Source: https://en.wikipedia.org/wiki/Random_number_generation