# stats::weibullRandom

Generate a random number generator for Weibull deviates

### Use only in the MuPAD Notebook Interface.

This functionality does not run in MATLAB.

## Syntax

```stats::weibullRandom(`a`, `b`, <`Seed = s`>)
```

## Description

`stats::weibullRandom(a, b)` returns a procedure that produces Weibull deviates (random numbers) with shape parameter `a` > 0 and scale parameter `b` > 0.

The procedure `f := stats::weibullRandom(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 nonnegative floating-point number.

In all other cases, `stats::weibullRandom(a, b)()` is returned symbolically.

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

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

Without the option `Seed` = `s`, 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::weibullRandom` do not react to the environment variable `SEED`.

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

`f := stats::weibullRandom(a, b): f() \$k = 1..K;`

rather than by

`stats::weibullRandom(a, b)() \$k = 1..K;`

The latter call produces a sequence of generators each of which is called once. Also note that

`stats::weibullRandom(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 Weibull deviates with parameters `a` = 2 and `b` = :

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

`delete f:`

### Example 2

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

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

When positive real numbers are assigned to `a` and `b`, the function `f` starts to produce random floating point numbers:

`a := PI: b := 1/8: 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::weibullRandom(PI, 3, Seed = 1): f() \$ k = 1..4`

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

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

`delete f, g:`

## Parameters

 `a` The shape parameter: an arithmetical expression representing a positive real value `b` The scale parameter: an arithmetical expression representing a positive real value

## Options

 `Seed` Option, specified as `Seed = s` Initializes the random generator with the integer seed `s`. `s` 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 `s` 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 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 Weibull deviates uses the quantile function of the Weibull distribution applied to unformly distributed random numbers on the interval .