Random - based on :rand (not :random)

Hal9000

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

https://github.com/Hal9000/elixir_random

Comments and critiques are welcome.

Thanks,
Hal

The Random module is based on Erlang’s rand module. (See rand — OTP 29.0.2 (stdlib 8.0.1) ).
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.

23 comments

#library

7 9549 23

2017-02-01 11:29:41 UTC

Showing Posts 1 to 10

Show Best Posts
Show All (oldest first)
Show All (newest first)

OvermindDL1

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

Post #1

josevalim

Creator of Elixir

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).

Post #2

Hal9000

I’m happy to assist any way I can.

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

Hal

Post #3

josevalim

Creator of Elixir

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.

Post #4

Hal9000

I don’t mind sending a proposal.

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

Hal

Post #5

OvermindDL1

It would be to the central Elixir github I would imagine (correct me otherwise?): GitHub - elixir-lang/elixir: Elixir is a dynamic, functional language for building scalable and maintainable applications · GitHub

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.

Post #6

Hal9000

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.

Hal

Post #7

josevalim

Creator of Elixir

You can clone the Elixir repo and then run:

make compile

Then you can add the code implementation around here:

https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1537

And the tests around here:

https://github.com/elixir-lang/elixir/blob/master/lib/elixir/test/elixir/kernel_test.exs#L87

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!

Post #8

Hal9000

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]

Duh?

Hal

Post #9

OvermindDL1

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.

Post #10

Load more posts (13 remaining)