# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English verison of the page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

# `stats`::`betaRandom`

Generate a random number generator for beta deviates

MuPAD® notebooks are not recommended. Use MATLAB® live scripts instead.

MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.

## Syntax

```stats::betaRandom(`a`, `b`, <`Seed = n`>)
```

## Description

`stats::betaRandom(a, b)` returns a procedure that produces beta deviates (random numbers) with shape parameters a > 0, b > 0.

The procedure `f := stats::betaRandom(a, b)` can be called in the form `f()`. The return value of `f()` is either a floating-point number or a symbolic expression:

• If `a` and `b` can be converted to positive floating-point numbers, then `f()` returns a random floating-point number between `0.0` and `1.0`.

• In all other cases, f() return the symbolic call `stats::betaRandom(a, b)()`.

Numerical values of `a` and `b` are only accepted if they are positive.

The values `X = f()` are distributed randomly according to the beta distribution with parameters `a` and `b`. For any 0 ≤ x ≤ 1, the probability that Xx is given by

.

Without the option `Seed` = `n`, an initial seed is chosen internally. This initial seed is set to a default value when MuPAD® is started. Thus, each time MuPAD is started or re-initialized with the `reset` function, random generators produce the same sequences of numbers.

### Note

In contrast to the function `random`, the generators produced by `stats::betaRandom` do not react to the environment variable `SEED`.

For efficiency, it is recommended to produce sequences of K random numbers via

`f := stats::betaRandom(a, b): f() \$ k = 1..K;`
rather than by
`stats::betaRandom(a, b)() \$ k = 1..K;`
The latter call produces a sequence of generators each of which is called once. Also note that
`stats::betaRandom(a, b, Seed = n)() \$ k = 1..K;`
does not produce a random sequence, because a sequence of freshly initialized generators would be created each of them producing the same number.

## Environment Interactions

The function is sensitive to the environment variable `DIGITS` which determines the numerical working precision.

## Examples

### Example 1

We generate beta deviates with parameters a = 2 and :

`f := stats::betaRandom(2, 3/4): f() \$ k = 1..4`

`delete f:`

### Example 2

With symbolic parameters, no random floating-point numbers can be produced:

`f := stats::betaRandom(a, b): f()`

When `a` and `b` evaluate to positive real numbers, the generator starts to produce random numbers:

`a := 1: b := 2: f() \$ k = 1..4`

`delete f, a, b:`

### Example 3

We use the option `Seed = s` to reproduce a sequence of random numbers:

`f := stats::betaRandom(1, 3, Seed = 1): f() \$ k = 1..4`

`g := stats::betaRandom(1, 3, Seed = 1): g() \$ k = 1..4`

`f() = g(), f() = g()`

`delete f, g:`

## Parameters

 `a`, `b` The shape parameters of the beta distribution: arithmetical expressions representing positive real values.

## Options

 `Seed` Option, specified as `Seed = n` Initializes the random generator with the integer seed `n`. `n` can also be the option `CurrentTime`, to make the seed depend on the current time. This option serves for generating generators that return predictable sequences of pseudo-random numbers. The generator is initialized with the seed `n` which may be an arbitrary integer. Several generators with the same initial seed produce the same sequence of numbers. When this option is used, the shape parameters `a` and `b` must be convertible to positive floating-point numbers at the time when the random generator is generated.

## Algorithms

The implemented algorithm for the computation of the beta deviates uses gamma deviates `x`, `y` to produce a beta deviate `x/(x + y)`. For more information see: D. Knuth, Seminumerical Algorithms (1998), Vol. 2, p. 134.