Pseudo-random numbers are generated from a random state object, which
can be created with `seed->random-state`

. The `state`
parameter to the various functions below is optional, it defaults to
the state object in the `*random-state*`

variable.

— Scheme Procedure: **copy-random-state** [`state`]

— C Function:**scm_copy_random_state** (`state`)

— C Function:

Return a copy of the random state

state.

— Scheme Procedure: **random**` n `[`state`]

— C Function:**scm_random** (`n, state`)

— C Function:

Return a number in [0,

n).Accepts a positive integer or real n and returns a number of the same type between zero (inclusive) and

n(exclusive). The values returned have a uniform distribution.

— Scheme Procedure: **random:exp** [`state`]

— C Function:**scm_random_exp** (`state`)

— C Function:

Return an inexact real in an exponential distribution with mean 1. For an exponential distribution with mean

uuse`(*`

u`(random:exp))`

.

— Scheme Procedure: **random:hollow-sphere!**` vect `[`state`]

— C Function:**scm_random_hollow_sphere_x** (`vect, state`)

— C Function:

Fills

vectwith inexact real random numbers the sum of whose squares is equal to 1.0. Thinking ofvectas coordinates in space of dimensionn=`(vector-length`

vect`)`

, the coordinates are uniformly distributed over the surface of the unit n-sphere.

— Scheme Procedure: **random:normal** [`state`]

— C Function:**scm_random_normal** (`state`)

— C Function:

Return an inexact real in a normal distribution. The distribution used has mean 0 and standard deviation 1. For a normal distribution with mean

mand standard deviationduse`(+`

m`(*`

d`(random:normal)))`

.

— Scheme Procedure: **random:normal-vector!**` vect `[`state`]

— C Function:**scm_random_normal_vector_x** (`vect, state`)

— C Function:

Fills

vectwith inexact real random numbers that are independent and standard normally distributed (i.e., with mean 0 and variance 1).

— Scheme Procedure: **random:solid-sphere!**` vect `[`state`]

— C Function:**scm_random_solid_sphere_x** (`vect, state`)

— C Function:

Fills

vectwith inexact real random numbers the sum of whose squares is less than 1.0. Thinking ofvectas coordinates in space of dimensionn=`(vector-length`

vect`)`

, the coordinates are uniformly distributed within the unitn-sphere.

— Scheme Procedure: **random:uniform** [`state`]

— C Function:**scm_random_uniform** (`state`)

— C Function:

Return a uniformly distributed inexact real random number in [0,1).

— Scheme Procedure: **seed->random-state**` seed`

— C Function:**scm_seed_to_random_state** (`seed`)

— C Function:

Return a new random state using

seed.

— Variable: ***random-state***

The global random state used by the above functions when the

stateparameter is not given.

Note that the initial value of `*random-state*`

is the same every
time Guile starts up. Therefore, if you don't pass a `state`
parameter to the above procedures, and you don't set
`*random-state*`

to `(seed->random-state your-seed)`

, where
`your-seed`

is something that *isn't* the same every time,
you'll get the same sequence of “random” numbers on every run.

For example, unless the relevant source code has changed, ```
(map
random (cdr (iota 30)))
```

, if the first use of random numbers since
Guile started up, will always give:

(map random (cdr (iota 19))) ⇒ (0 1 1 2 2 2 1 2 6 7 10 0 5 3 12 5 5 12)

To use the time of day as the random seed, you can use code like this:

(let ((time (gettimeofday))) (set! *random-state* (seed->random-state (+ (car time) (cdr time)))))

And then (depending on the time of day, of course):

(map random (cdr (iota 19))) ⇒ (0 0 1 0 2 4 5 4 5 5 9 3 10 1 8 3 14 17)

For security applications, such as password generation, you should use more bits of seed. Otherwise an open source password generator could be attacked by guessing the seed... but that's a subject for another manual.