protocol

# randomp

> Random number generator protocol.

author:
  `Paulo Moura`
version:
  `2.3`
date:
  `2018/7/20`

compilation flags:
  `static`

(no dependencies on other entities)

## Public interface

### random/1

> Returns a new random float value in the interval [0.0, 1.0[.

compilation flags:
  `static`
template:
  `random(Random)`
mode – number of proofs:
  `random(-float) – one`

### between/3

> Returns a new random integer in the interval [Lower, Upper]. Fails if Lower or Upper are not integers or if Lower > Upper.

compilation flags:
  `static`
template:
  `between(Lower,Upper,Random)`
mode – number of proofs:
  `between(+integer,+integer,-integer) – zero_or_one`

### member/2

> Returns a random member of a list. Fails if the list is empty.

compilation flags:
  `static`
template:
  `member(Random,List)`
mode – number of proofs:
  `member(-term,+list(term)) – zero_or_one`

### select/3

> Returns a random member of a list and the rest of the list. Fails if the list is empty.

compilation flags:
  `static`
template:
  `select(Random,List,Rest)`
mode – number of proofs:
  `select(-term,+list(term),-list(term)) – zero_or_one`

### permutation/2

> Returns a random permutation of a list.

compilation flags:
  `static`
template:
  `permutation(List,Permutation)`
mode – number of proofs:
  `permutation(+list,-list) – one`

### sequence/4

> Returns a list of the given length of random integers in random order in the interval [Lower, Upper]. Fails if Length, Lower, or Upper are not integers or if Lower > Upper.

compilation flags:
  `static`
template:
  `sequence(Length,Lower,Upper,List)`
mode – number of proofs:
  `sequence(+integer,+integer,+integer,-list(integer)) – zero_or_one`

### set/4

> Returns an ordered set of the given size of random integers in the interval [Lower, Upper]. Fails if Length, Lower, or Upper are not integers, if Lower > Upper, or if Length > Upper - Lower + 1.

compilation flags:
  `static`
template:
  `set(Length,Lower,Upper,Set)`
mode – number of proofs:
  `set(+integer,+integer,+integer,-list(integer)) – zero_or_one`

### random/3

> Returns a new random value in the interval [Lower, Upper[. Fails if Lower > Upper. Deprecated. Use between/3 for integers.

compilation flags:
  `static`
template:
  `random(Lower,Upper,Random)`
mode – number of proofs:
  `random(+integer,+integer,-integer) – zero_or_one`
  `random(+float,+float,-float) – zero_or_one`

### randseq/4

> Returns a list of the given length of random values in random order in the interval [Lower, Upper[. Fails if Lower > Upper or if the arguments are neither integers or floats. Deprecated. Use sequence/4 for integers.

compilation flags:
  `static`
template:
  `randseq(Length,Lower,Upper,List)`
mode – number of proofs:
  `randseq(+integer,+integer,+integer,-list(integer)) – zero_or_one`
  `randseq(+integer,+float,+float,-list(float)) – zero_or_one`

### randset/4

> Returns an ordered set of the given size of random values in the interval [Lower, Upper[. Fails if the arguments are neither integers or floats, Lower > Upper, or Length > Upper - Lower when the arguments are integers. Deprecated. Use set/4 for integers.

compilation flags:
  `static`
template:
  `randset(Length,Lower,Upper,Set)`
mode – number of proofs:
  `randset(+integer,+integer,+integer,-list(integer)) – zero_or_one`
  `randset(+integer,+float,+float,-list(float)) – zero_or_one`

### get_seed/1

> Gets the current random generator seed. Seed should be regarded as an opaque ground term.

compilation flags:
  `static`
template:
  `get_seed(Seed)`
mode – number of proofs:
  `get_seed(-ground) – one`

### set_seed/1

> Sets the random generator seed to a given value returned by calling the get_seed/1 predicate.

compilation flags:
  `static`
template:
  `set_seed(Seed)`
mode – number of proofs:
  `set_seed(+ground) – one`

### maybe/0

> Succeeds or fails with equal probability.

compilation flags:
  `static`
mode – number of proofs:
  `maybe – zero_or_one`

### maybe/1

> Succeeds with probability Probability or fails with probability 1 - Probability. Fails if Probability is not a float or is outside the interval [0.0, 1.0].

compilation flags:
  `static`
template:
  `maybe(Probability)`
mode – number of proofs:
  `maybe(+probability) – zero_or_one`

### maybe/2

> Succeeds with probability K/N where K and N are integers satisfying the equation 0 =< K =< N. Fails otherwise.

compilation flags:
  `static`
template:
  `maybe(K,N)`
mode – number of proofs:
  `maybe(+non_negative_integer,+non_negative_integer) – zero_or_one`

## Protected interface

(none)

## Private predicates

(none)

## Operators

### (none)

## Remarks

### (none)

## See also

### (none)