Random Number Generators

Random Number Generator: How Do Computers Generate Random Numbers?

People have been playing random numbersfor millennia. Hence, the idea isn't completely new. From the lottery games of the ancient city of Babylon, to Roulette tables at Monte Carlo, to dice games in Vegas, the goal is to leave the end result up to random chance.

However, aside from gambling, randomnesshas numerous applications in science, statistics, cryptographyand other areas. However, using dice, coins or other similar media as a random device has its limitations.

Due to their mechanical character of techniques, generatinglarge quantities of random numbers requires great deal of time and work. Because of human creativity, we have more efficient tools and methods available to us.

Methods of generating random numbers

True Random Numbers

Photograph of analog-input digital-output processor device. Photo by Harrison Broadbent

Let's look at two main techniques used to generate random numbers. The second methodis The first method isbased on physical processes, and seeks out the source of randomness from a phenomena that's thought to be random.

The phenomenon is observed outside of the computer. It is measured and adjusted to correct for possible biases that result from measuring processes. Examples include photoelectric effect cosmic background radiation atmospheric noise (which we will discuss for this essay) and many other sources.

So, random numbers created in the context of such randomness can be said to be " true" random numbers.

Technically, the hardware part comprises a component that converts energy from one form to another (for example, radiation is converted into electricity) along with an amplifier and an analog-to digital converter to convert the output into a digital number.

What are Pseudorandom Numbers?

Picture of computer code flowing through computer screen. Photo by Markus Spiske.

As an alternative instead of "true" random numbers, the alternative technique for generating random numbers involves computational algorithms that can produce apparently random results.

How can this be so? The final results are in fact completely dependent on an initial value which is also known as the seed key or keys. If you were aware of the value of the key, and also how the algorithm functions then you can reproduce these almost random results.

Random number generators of this kind are typically referred to Pseudorandom number generators. They, as consequence, they generate pseudodorandom numbers.

Even though this kind of generator generally doesn't collect any information from sources of naturally occurring randomness, this kind of gathering of keys is feasible when required.

Let's review some similarities between TRNGs, or true random number generators. TRNGs and pseudorandom number generators or PRNGs.

PRNGs run faster than TRNGs. Because of their deterministic nature they are helpful when you want to replay a sequence of random events. This can help a lot in testing code for instance.

However TRNGs aren't regular and are better suited for critical security roles like encryption.

It is said that a duration is the number of iterations a PRNG goes through before it repeats itself. So, all else being the same, a PRNG that has more time will require more computing power to predict and then crack.

Example Algorithm for Pseudo-Random Number Generator

The computer's execution is founded on a set rules to be followed. For all PRNGs the rules are the following:

1. Accept an initial input code, which is a seed or key.
2. Apply the seed to an order of mathematical operations to create the result. The result is a random number.
3. Use the resultant random number as the seed for the following iteration.
4. Repeat the process until you achieve randomness.

Let's now look at an illustration.

The Linear Congruential Generator

The generator creates a series of pseudorandom numbers. With an initial seed X0 and integer parameters such as a as the multiplier and in the form of an increment, and m as the modulus the generator can be described using the linear relation: The formula is: Xn (aXn-1 + b)mod the modulus m. Or using more programming friendly syntax: X _n = (a * X _n-1 + b) % 1.

Each of the members has to meet the following requirements:

• m > 0.(the modification is positive),
• 1 a m(the multiplyer can be positive but is less than that of the modulus),
• 0.= the modulus is b (the increment isn't negative, but it's less than the modulus) and
• 0X ₀ < 1(the seed is not negative but less than that of the modulus).

Let's create an JavaScript function that will take the initial values as arguments and then return an assortment of random numbers of length a specified length

  // x0=seed; a=multiplier; b=increment; m=modulus; n=desired array length; const linearRandomGenerator = (x0, a, b, m, n) =>  const results = [] for (let i = 0; i < n; i++)  x0 = (a * x0 + b) % m results.push(x0)  return results  

The Linear Congruential Generator (LCG) is among of the most popular and oldest PRNG algorithms.

In the case of random number generator algorithms which can be run by computers, they are in use as early as the 1940s and 50s (the Middle-square method and Lehmer generator, for example) and continue to be written today ( Xoroshiro128+, Squares RNG and many more).

A Sample Random Number Generator

When I decided to write this post about embedding a random number generator on an online page, I had a choice to make.

It is possible to use JavaScript's Math.random()function to serve as the basis and then generated output in pseudorandom numbers as I've done in earlier articles (see Multiplication Chart - Code Your Own Time Table).

However, this post involves generating random numbers. So I set out to discover how to gather "true" randomness based data and share it with you.

So below what is "true" Random Number Generator. Choose the parameters and then hit Generate.True Random Number GeneratorBinary Decimal Hexadecimal GenerateResult:

The code retrieves data from one of the APIs thanks to Random.org. The site has many useful tools that can be customized and comes with a great documentation with it.

The randomness is due to atmospheric noise. I was able to utilize Asynchronous functions. That is a huge benefit moving forward. The fundamental function is this:

// Generates a random number within user indicated interval const getRandom = async (min, max, base) =>   const response = await  fetch("https://www.random.org/integers/?num=1&min="+min+"  &max="+max+"&col=1&base="+base+"&format=plain&rnd=new")  return response.text()   

The parameters it requires allow the user to alter the output of random numbers. For example, min and max permit you to define upper and lower limits on generated output. Also, base determines whether output is printed as decimal, binary or the hexadecimal.

In the end, I went with this particular configuration, but there are many more available from the source.

If you click the Generate button after which then the handleGenerate() function is called. It in turn invokes the getRandom() asynchronous function and handles error handling and then outputs results:

// Output handling const handleGenerate = () =>  !maximum.value)  prompter.style.color = 'red' prompter.textContent = "Enter Min & Max values"  else  getRandom(minimum.value, maximum.value, base).then((data) =>  resultValue.textContent = data prompter.textContent = "" ).catch((error) => create';) handleRestart()  

The rest of the code deals with HTML structures, look, and styling.

It is now ready to be embedded and utilized on this page. I divided it into components pieces and provided it with specific notes. It can be easily modified. You can alter the functionality and styles as your requirements demand.