# Managing the Global Stream Using `RandStream`

The `rand`, `randn`, `randi`, and `randperm` functions draw random numbers from an underlying random number stream, called the global stream. The global stream is a `RandStream` object. A simple way to control the global stream is to use the `rng` function. For more comprehensive control, the `RandStream` class enables you to create a separate stream from the global stream, get a handle to the global stream, and control random number generation.

Use `rng` to initialize the random number generator. Set the generator seed to 0 and the generator algorithm to Mersenne Twister. Save the generator settings.

```rng(0,'twister') s = rng```
```s = struct with fields: Type: 'twister' Seed: 0 State: [625x1 uint32] ```

Create a 1-by-6 row vector of uniformly distributed random values between 0 and 1.

`x = rand(1,6)`
```x = 1×6 0.8147 0.9058 0.1270 0.9134 0.6324 0.0975 ```

Use `RandStream.getGlobalStream` to return a handle to the global stream, that is, the current global stream that `rand` generates random numbers from. If you use `RandStream.getGlobalStream` to get a handle to the global stream, you can see the changes you made to the global stream using `rng`.

`globalStream = RandStream.getGlobalStream`
```globalStream = mt19937ar random stream (current global stream) Seed: 0 NormalTransform: Ziggurat ```

Change the generator seed and algorithm, and create a new random row vector. Show the current global stream that `rand` generates random numbers from.

```rng(1,'philox') xnew = rand(1,6)```
```xnew = 1×6 0.5361 0.2319 0.7753 0.2390 0.0036 0.5262 ```
`globalStream = RandStream.getGlobalStream`
```globalStream = philox4x32_10 random stream (current global stream) Seed: 1 NormalTransform: Inversion ```

Next, restore the original generator settings and create a random vector. The result matches the original row vector `x` created with the initial generator.

```rng(s) xold = rand(1,6)```
```xold = 1×6 0.8147 0.9058 0.1270 0.9134 0.6324 0.0975 ```

By default, random number generation functions, such as `rand`, use the global random number stream. To specify a different stream, create another `RandStream` object. Pass it as the first input argument to `rand`. For example, create a 1-by-6 vector of random numbers using the SIMD-oriented Fast Mersenne Twister.

`myStream = RandStream('dsfmt19937')`
```myStream = dsfmt19937 random stream Seed: 0 NormalTransform: Ziggurat ```
`r = rand(myStream,1,6)`
```r = 1×6 0.0306 0.2131 0.2990 0.3811 0.8635 0.1334 ```

When you call the `rand` function with `myStream` as the first input argument, it draws numbers from `myStream` and does not affect the results of the global stream.

If you want to set `myStream` as a global stream, you can use the `RandStream.setGlobalStream` object function.

```RandStream.setGlobalStream(myStream) globalStream = RandStream.getGlobalStream```
```globalStream = dsfmt19937 random stream (current global stream) Seed: 0 NormalTransform: Ziggurat ```

In many cases, the `rng` function is all you need to control the global stream, but the `RandStream` class allows control over some advanced features, such as the choice of algorithm used for normal random values.

For example, create a `RandStream` object and specify the transformation algorithm to generate normally distributed pseudorandom values when using `randn`. Generate normally distributed pseudorandom values using the `Polar` transformation algorithm, instead of the default `Ziggurat` transformation algorithm.

`myStream = RandStream('mt19937ar','NormalTransform','Polar')`
```myStream = mt19937ar random stream Seed: 0 NormalTransform: Polar ```

Set `myStream` as the global stream. Create 6 random numbers with normal distribution from the global stream.

```RandStream.setGlobalStream(myStream) randn(1,6)```
```ans = 1×6 0.2543 -0.7733 -1.7416 0.3686 0.5965 -0.0191 ```