# How do you do random?

###
David J Eddy
Oct 5
*Updated on Oct 07, 2018 *

I was watching a VueJS tutorial and was surprised at what it takes in ECMAscript to generate a random integer between 0 and 10.

```
Math.floor(Math.random() * 10);
```

In PHP it takes

```
mt_rand(0, 10);
```

In your favorite language what does it take to generate an integer between 0 and 10?

dev.to is where software developers stay in the loop and avoid career stagnation.
Signing up (for free!) is the first step.

Classic DEV Post from Apr 16

More from @david_j_eddy

What are your favorite VueJS libraries?
#javascript
#webdev
#vue
#discuss

Trending on dev.to

Protected Routes in React using React Router
#react
#javascript
#webdev
#video

Why you need to know about the Lindy effect, as a developer.
#javascript
#webdev
#career
#discuss

Deploy a React app on heroku the right way
#heroku
#react
#deployment
#webdev

"youtube.com" is down - proving it with UI testing!
#showdev
#devops
#hugops

Practical Patterns with React Easy State
#react
#javascript
#webdev
#state

What is Data Binding?
#javascript
#webdev
#beginners
#data

Don't code your microservice like a monolith, keep it maintainable not over-engineered
#tips
#webdev
#devops
#productivity

How to split a new feature into independent (release ready) parts before coding it
#webdev
#tips
#productivity
#beginners

`const random = 7;`

xkcd.com/221/

π€£

Pfff, everyone knows

`random`

is`4`

not`7`

.Pfff, you need update your mindset π€¨

Updates just break everything.

How can you know that no consumer of your code assumes it will be

`4`

?Sure, you

claimedit is random, in the "documentation", but it's not like that ever works.You made my day π€£π€£

`Math.random()`

produces a random`float`

(all JavaScript numbers are of type`float`

) from`0`

to`1`

.Adding the requirement of 0-10 means you have to multiply by 10 or

`* 10`

.The last requirement was the number must be an

`Integer`

, which is the`math.floor`

.Of course, if you only wanted a random float between

`0`

and`1`

, it would be just one call.And in PHP if you wanted a random float between 0 and 1, you would also have to do more work: Random Float between 0 and 1 in PHP

So the complexity actually comes from the requirements you give it.

But asking for a random integer is a common task. So it's handy to create function and keep it in your library. Don't go sprinkling

`Math.floor(Math.random() * 10)`

randomly around your codebase :DP.S. I prefixed this with

`pseudo`

because there is no true Random in JavaScript. This is very important when it comes to cryptography. Google`PRNG`

if you want to learn more.For a cryptographically strong random value, you might want to look into Crypto.getRandomValues()

Cheers!

I wish PM's understood this more.

There's a bug in your example; if the output is supposed to be

`[start, end)`

, then the correct implementation is:βπ

I probably should have run it once. lol.

I gotta stop typing code directly into editors.

Good catch!

There is a subtle bug to consider with your code, though. If you want to guarantee an even spread among the numbers in the set of

`[0, 10]`

, you'll have problems with`10`

never showing up in your histogram. The reason for this is that the random value will almost never be exactly`1`

, as most PRNGs will actually output something in the range of`[0, 1)`

(note the non-inclusiveness of`1`

in the return values).To correct that problem, you have to be a little smarter about how you map the

`[0,1]`

interval to buckets of integers:In the case of

`10`

, you'll be multiplying a number in the`[0,1]`

range to something that's just under`11`

. Number.EPSILON is the smallest float fraction that JavaScript numbers can express, so it's as close as the JavaScript number precision gets. And because the number`11`

is never a value that appears in the output,`Math.floor`

will never return anything above`10`

, guaranteed.Of course, if your PRNG never returns

`1`

in its output, it's safe to just do`max + 1`

. :)Here's an illustration:

repl.it/@KrofDrakula/safeRandom

What about using

`Math.round()`

in place of`Math.floor()`

in the original?In that case,

`0`

and`10`

would appear with about 50% the frequency of every other element.If you imagine the number line after multiplying by 10, you'll understand what I mean:

This diagram shows you which floats map to which integer with different functions. As you can see, in the case of

`Math.round()`

,`0`

has only half the length of every other number, so it would appear half as often. Same goes for`10`

at the end of the interval:While

`10`

would appear in the resulting histogram, its frequency would be about half the frequency of every other non-zero integer.FYI, Math.round() is just:

You're effectively just shifting the mapping from floats to integers, but you're not making room for the

`max`

number. To have even distribution, you must have all intervals of equal length, and all the intervals covered by the scaled random number interval.Also, try out the above repl.it link, you can make your own random functions to see if your hunches are correct. :)

I'm on my smartphone at the moment, but thanks. Your other response makes a lot of sense. That's something I hadn't thought about before.

Going the OG route

Python:

Ruby:

Go:

None of these are cryptographically secure though

Python has a cryptographically secure library called "secrets", which I use a lot :-P

Yeah secrets is very useful and has a clear API

Python has a few options, including the numpy module. Regardless of language, however, it often only takes a ~20 lines to define a pseudo-random (in numerical math we avoid saying "random") number generator method. Here is an implementation of the so-called Mersenne twister:

In this method, we declare two integers, i (16807 = 7

^{5),}and j (the Mersenne prime). In specifying the arguments n (number of psuedo-random numbers desired), seed (for repeatability of the pseudo-random numbers), and S (min, max, types to be generated), what is repeatedly happening (depending on n) is that we are taking the remainder of (seed * i) and j, and dividing by j; over and over. This implementation of the Mersenne Twister is good for about 2^{30}random numbers before it repeats itself. :)APL:

I am a beginner in this language but it is fascinating at how succinct and elegant some constructs are.

I originally found it on the Hey, Scripting Guy! blog, but it's pretty simple to use:

Where

`Count`

is how many random numbers you wish to generate, and`InputObject`

is an array of the range of numbers you want to choose from.I'm a tester and I use random in my automation. In groovy, I use:

`import org.apache.commons.lang.RandomStringUtils as RandomStringUtils`

WebUI.setText(findTestObject('someWhereToPutNumbers'),RandomStringUtils.randomNumeric(4))

In PL/SQL:

A random number.

A random round number.

A random number between two values.

Others responded on-topic, so I would add an off-topic :)

I do not build a JS project without Lodash (or something similar), it covers the basic needs and lacks of JS, acting like a

Standard libraryin other languages. A few of them are related to randomDevs should be more careful at the distributions, most of the cases the code will be used for a few values and a small range of values, which will lead to very not-so-random results.

If the random results will affect the User Experience you should think twice of using it, the screwed distribution will affect your sales and KPIs in unknown ways, most likely negative, and there are always better alternatives, that require more resources to implement of course.

From a terminal can be(no for encrypt things):

They see me shuffling. LMFAO

In kotlin

Or

Thanks to the Random api in the stdlib this works in the JVM, Kotlin.js and Kotlin native

RPL for HP48/50 series

`<< RAND 10 * FLOOR >>`

Don't trust your own computer for randomness. Better trust a webservice. ;-)

I had a workshop about random numbers at the CodePenDay 2017 in Hamburg by Bullgit: github.com/bullgit/fair-random

rand 0..10

Ruby

## Generates an integer between 0 and 10 In Python

from random import randint

print(randint(0, 10))

real(8) :: r

integer :: i

CALL RANDOM_NUMBER(r)

i = floor(r *10.0)

JS still works better than C to randomly generate and have the numbers actually be random π

In clojure it's (rand-int 11) which you can also use in clojurescript.