random_protocol — Logtalk 3.100.1

protocol

# `random_protocol`

Random number generator protocol. The predicates are declared as synchronized when the library is compiled using a backend supporting threads.

Availability:
`logtalk_load(random(loader))`
Author: Paulo Moura
Version: 3:3:0
Date: 2023-11-24
Compilation flags:
`static`
Dependencies:
(none)
Remarks:
(none)
Inherited public predicates:
(none)

## Public predicates

### `random/1`

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

Compilation flags:
`static, synchronized`
Template:
`random(Random)`
Mode and 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 and 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 and 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 and number of proofs:
`select(-term,+list(term),-list(term))` - `zero_or_one`

### `select/4`

Returns a random member of a list, replacing it with a new element and returning the resulting list.

Compilation flags:
`static`
Template:
`select(Random,OldList,New,NewList)`
Mode and number of proofs:
`select(-term,+list(term),@term,-list(term))` - `zero_or_one`

### `swap/2`

Swaps two randomly selected elements of a list. Fails if the list is empty or contains a single element.

Compilation flags:
`static`
Template:
`swap(OldList,NewList)`
Mode and number of proofs:
`swap(-term,+list(term))` - `zero_or_one`

### `swap_consecutive/2`

Swaps two randomly selected consecutive elements of a list. Fails if the list is empty or contains a single element.

Compilation flags:
`static`
Template:
`swap_consecutive(OldList,NewList)`
Mode and number of proofs:
`swap_consecutive(-term,+list(term))` - `zero_or_one`

### `enumerate/2`

Enumerates the elements of a list in random order. Fails if the list is empty.

Compilation flags:
`static`
Template:
`enumerate(List,Random)`
Mode and number of proofs:
`enumerate(+list(term),--term)` - `zero_or_more`

### `permutation/2`

Returns a random permutation of a list.

Compilation flags:
`static, synchronized`
Template:
`permutation(List,Permutation)`
Mode and number of proofs:
`permutation(+list,-list)` - `one`

### `sequence/4`

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

Compilation flags:
`static, synchronized`
Template:
`sequence(Length,Lower,Upper,List)`
Mode and number of proofs:
`sequence(+integer,+integer,+integer,-list(integer))` - `zero_or_one`

### `set/4`

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

Compilation flags:
`static, synchronized`
Template:
`set(Length,Lower,Upper,Set)`
Mode and 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, synchronized`
Template:
`random(Lower,Upper,Random)`
Mode and number of proofs:
`random(+integer,+integer,-integer)` - `zero_or_one`
`random(+float,+float,-float)` - `zero_or_one`

### `randseq/4`

Returns list of random values of given length in random order in 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, synchronized`
Template:
`randseq(Length,Lower,Upper,List)`
Mode and number of proofs:
`randseq(+integer,+integer,+integer,-list(integer))` - `zero_or_one`
`randseq(+integer,+float,+float,-list(float))` - `zero_or_one`

### `randset/4`

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

Compilation flags:
`static, synchronized`
Template:
`randset(Length,Lower,Upper,Set)`
Mode and number of proofs:
`randset(+integer,+integer,+integer,-list(integer))` - `zero_or_one`
`randset(+integer,+float,+float,-list(float))` - `zero_or_one`

### `maybe/0`

Succeeds or fails with equal probability.

Compilation flags:
`static`
Mode and 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 and 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 and number of proofs:
`maybe(+non_negative_integer,+non_negative_integer)` - `zero_or_one`

### `maybe_call/1`

Calls a goal or fails without calling it with equal probability. When the goal is called, it determines if this predicate succeeds once or fails.

Compilation flags:
`static`
Template:
`maybe_call(Goal)`
Meta-predicate template:
`maybe_call(0)`
Mode and number of proofs:
`maybe_call(+callable)` - `zero_or_one`

### `maybe_call/2`

Calls a goal or fails without calling it with probability `Probability`. When the goal is called, it determines if this predicate succeeds once or fails.

Compilation flags:
`static`
Template:
`maybe_call(Probability,Goal)`
Meta-predicate template:
`maybe_call(*,0)`
Mode and number of proofs:
`maybe_call(+probability,+callable)` - `zero_or_one`

## Protected predicates

(none)

## Private predicates

(none)

## Operators

(none)

See also

random, backend_random, fast_random