Random - based on :rand (not :random)

Here is my first stab at this. README pasted below.


Comments and critiques are welcome.


The Random module is based on Erlang’s rand module. (See http://erlang.org/doc/man/rand.html ).
This in turn is a newer replacement for Erlang’s deprecated random.

All functionality of rand is preserved here. The primary differences are:

  • The preferred function name is rand (although uniform and normal will still work, for people accustomed to those).
  • rand takes a parameter :normal for normal-distribution results.
  • The _s functions are unnecessary, as state is passed (as needed) by means of an optional parameter.
  • Any function that accepts a state also returns the new state (second item in tuple); other functions simply return a number.
  • A distinction is made between seed and seed3 (the latter of which takes a tuple of three integers rather than a state).
  • The functions export_seed and export_seed_s are not really needed any longer.
  • The rand function can take a range, e.g. rand(50..60).
  • The Random module adds sample (which takes a second parameter, a number defaulting to 0); this calls Enum.take_random which works on any enumerable.
  • The Random module adds shuffle (which simply calls Enum.shuffle and thus can take any enumerable.
  • The PRNG is seeded on module load (default algorithm is :exsplus just as with :rand); you may of course reseed at any time.


x = Random.rand             # Random number between 0.0 and 1.0

x = Random.rand(:normal)    # Random number in normally-distributed range, -1..1 is one sigma

n = Random.rand(5)          # Random integer between 1 and 5

n = Random.rand(10..20)     # Random integer between 10 and 20

state = Random.seed(:exsplus)               # Use the explus algorithm (default), Xorshift116+, 58 bits, period = 2^116-1

state = Random.seed(:exs64)                 # Use the exs64 algorithm, Xorshift64, 64 bits, period = 2^64-1

state = Random.seed(:exs1024)               # Use the exs1024 algorithm, Xorshift1024, 64 bits, period = 2^1024-1

state = Random.seed3(:exsplus, {1, 2, 3})   # Seed using the three integers 1, 2, 3

state = Random.seed(:exsplus, state)        # Seed using the specified state

x = Random.uniform                          # Same as Random.rand

x = Random.normal                           # Same as Random.rand(:normal)

{x, state} = Random.rand(state)             # Specify state and return number and a new state

{x, state} = Random.rand(:normal, state)    # Specify state and return number (normal distribution) and new state

item = Random.sample(enum)                  # Grab one random item from any enumerable (such as a list)

list = Random.sample(enum, 3)               # Grab 3 random items from any enumerable (such as a list)

list = Random.shuffle(enum)                 # Randomize (shuffle) an enumerable (such as a list)


The sample and shuffle functions do not have state-sensitive variants.


Looks good. Unsure when I would get a chance to try it sadly, but good interface. :slight_smile:

I really like this too! I would love to hijack the rand function and make it part of Elixir’s Kernel. Would you be interested in sending a proposal or a PR to elixir for the rand/0 and rand/1 functions? It sounds like a perfect gateway to link developers to Erlang’s :rand. :slight_smile:

The only change I would possibly do is to drop support for rand(integer) since rand(0..5) is much more explicit than rand(5).


I’m happy to assist any way I can. :slight_smile:

  1. Not sure of process for proposal
  2. Do we want some version of seed also, if this is going into Kernel?
  3. I’m ok with dropping rand(n) – only kept for compatibility.


If you want to send a proposal, the planned API for rand, similar to what you have sent here, is enough. However, given the proposal is pretty much here already, it is ok to bypass that and send a PR if you prefer.

We don’t plan to have any seed or stateful function. The goal is to use rand/0 and rand/1 as a gateway to the actual :rand module. So we can explicitly document that you can get control over the seed by using the :rand module.

I don’t mind sending a proposal.

I just don’t know to whom I should send it.


It would be to the central Elixir github I would imagine (correct me otherwise?): https://github.com/elixir-lang/elixir/ :slight_smile:

If you can get a PR (Pull Request) started with the basic code as jose wants, then conversation can happen within that PR to refine it so you can add the refinements until it gets merged into core. :slight_smile:

I don’t know the source. It’s not obvious to me where this would go.

If anyone wants to assist, let me know. Or if I can simply submit
code/docs to someone, that is fine, too.

rand/0 and rand/1 are very few lines of code.


You can clone the Elixir repo and then run:

make compile

Then you can add the code implementation around here:

And the tests around here:

After writing code or tests, you can run the line below inside the Elixir repo to run one particular test:

elixirc lib/elixir/lib/kernel.ex -o lib/elixir/ebin && elixir lib/elixir/test/elixir/kernel_test.exs

If the tests pass, we are golden! If you would prefer to send the code and tests and not a PR, please just open up an issue!


I cloned the repo and added two functions and two tests (which pass).

Not sure how to proceed. Tried a push - got this:

ERROR: Sorry, but @elixir-lang has blocked access to SSH keys created by
some third-party applications. Your key was created before GitHub tracked
keys created by applications, so we need your help.

[blah blah, omitted]



Look up in the github docs about ‘forking’ and ‘making a pull request’. Basically you will fork (copy) their repo into your own place. Clone that one down. Branch it with a decent name (“add_rand” for example), make your changes, push those up to your repo, then in github submit a pull request on it (big button on the interface you cannot miss when you have a special feature branch like that).

I would give exact commands, but in a hurry. It is easy though once learned and github well documents it. :slight_smile:

1 Like

It’s not that easy at all, everytime I do it I have to look up the docs :smiley: But the docs are well written though :wink:

I do feel silly for not knowing that procedure. I will figure that out later,
as I am pressed for time right now.

If anyone wants to take this on, the changes are very small. I’ll paste
code (kernel.ex) and tests here.


  @doc ~S"""
  `rand/0` returns a (pseudo)random number between 0 and 1.
  `rand/1` can take a range as a parameter, returning an integer
  from that range.
  @spec rand() :: float
  def rand, do: :rand.uniform

  @spec rand(Range.t) :: integer
  def rand(n1..n2) when is_integer(n1) and is_integer(n2) do
    :rand.uniform(n2 - n1 + 1) + n1 - 1

  test "rand/0" do
    x = rand()
    assert is_float(x)
    assert x >= 0.0
    assert x <= 1.0

  test "rand/1" do
    n = rand(10..20)
    assert is_integer(n)
    assert n >= 10
    assert n <= 20

No worries, I have incorporated your changes to master here: https://github.com/elixir-lang/elixir/commit/786da1ffe075d50a26af885f4baf9589978c45c2


Is it boring for me to repeat that you are increadibly good in making people contribute to Elixir? I mean, you don’t even have to know pull request flow to do so, awesome!

@Hal9000 for the future you may want to learn the procedure however. It’s both easier for the maintainer and you get some respect badge in the hood by being listed on official contributor’s list (as in here: https://github.com/elixir-lang/elixir/graphs/contributors). If maintainer just copies the code, you are not listed (although in this particular case @josevalim was kind enough to mention you in the commit description!). Some people may care about this detail, others not, just letting you know :slight_smile:


Hubert speaks truth :wink: @josevalim is awesome on more than one level.

I will certainly learn this procedure for next time.

As for contributors’ list – if I ever contribute 1,000 lines of code, I will
care more. :slight_smile: I’m grateful to be mentioned, but I wouldn’t ask for mention
for 20 or so LOC.


Yeah Jose is truly awesome. It is so pleasant to be around a BDFL that speaks so nicely. ^.^

1 Like

I have a personal theory that in fact there are at least 3 @josevalim’s. You never know who is on the other end, since the visual contact is so rare. It’s physically impossible for one person to do so many awesome things.

1 Like

Hey does anyone knows what happend to this? I can’t find rand on master branch https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex nor 1.4 branch it seems that it was added here: https://github.com/elixir-lang/elixir/commit/786da1ffe075d50a26af885f4baf9589978c45c2 and removed here: https://github.com/elixir-lang/elixir/commit/8e2a1e58510dbefb5c707071fcba1584ba3b614f

@josevalim: Was it meant to be reintroduced with random name instead of rand and somehow did not because someone people just forget things? Or was there more to the story of removal of that code?

1 Like

The reason is in the commit message, Enum.random/1 already provides the functionality, so we decided to stick with it.

1 Like