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.
Examples
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)
Notes
The sample and shuffle functions do not have state-sensitive variants.
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.
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).
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.
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.
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.
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.
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.
Hal
@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
end
test "rand/0" do
x = rand()
assert is_float(x)
assert x >= 0.0
assert x <= 1.0
end
test "rand/1" do
n = rand(10..20)
assert is_integer(n)
assert n >= 10
assert n <= 20
end
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
Hubert speaks truth @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. I’m grateful to be mentioned, but I wouldn’t ask for mention
for 20 or so LOC.
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.
@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?
But the docs are well written though 
