# RVar

An instance of `RVar`

represents a computation that, when executed, results in a value with randomness applied. `RVar`

is one of the most important structures in CIlib and is therefore discussed first in order to understand how the data structure works.

`RVar`

has a monad instance and therefore allows a for a large amount of composition, but more importantly allows for the tracking of randomness within the `RVar`

computation. This tracking is of the utmost importance within computational intelligence algorithms, as randomness needs to be controlled in a manner that facilitates repetition. In other words, even if a computation uses randomness, given the same inputs, the same results are expected even with randomness applied.

Due to the monadic nature of the data structure, the data structure may be transformed by functions such as `map`

, `flatMap`

, etc

There are several predefined combinators that allow the user to use and create `RVar`

computations. These include functions for randomness applied to primitive types (such and `Int`

and `Double`

) to more complex types that build on the primitives, or even for user defined types.

The simplest would be to look at some examples of `RVar`

usage. It is quite common to request several random numbers. `RVar`

provides several functions, with `ints`

and `doubles`

being the most common for random variable creation:

```
scala> val ints = RVar.ints(5)
ints: cilib.RVar[List[Int]] = cilib.RVar$$anon$4@5d8460d4
scala> val doubles = RVar.doubles(5)
doubles: cilib.RVar[List[Double]] = cilib.RVar$$anon$4@72d0231
```

Both functions result in a `RVar`

that, when provided with a pseudo-random number generator (PRNG), will result in a list of values.

The user if free to define a PRNG for themselves, but CIlib provides a default PRNG that is suitable for scientific work. The CMWC generator may be initialized by either providing a seed value for the pseudo-random number stream, or it may be taken from the current time of the computer. It is always recommended to record the seed value, so that others may reproduce results, especially if the results are to be published.

Let’s create a `RNG`

instance using both methods:

```
scala> val rng = RNG.init(1234L)
rng: cilib.RNG = cilib.CMWC@40955bca
scala> val fromTimeYOLO = RNG.fromTime
fromTimeYOLO: cilib.RNG = cilib.CMWC@6ec323df
```

Now, let’s run both `doubles`

and `ints`

with the generator:

```
scala> val r1 = ints.run(rng)
r1: (cilib.RNG, List[Int]) = (cilib.CMWC@2542cbd8,List(-2012280037, -456312394, -1608573853, -1720473833, 1662253751))
scala> doubles.run(rng)
res0: (cilib.RNG, List[Double]) = (cilib.CMWC@4e157a62,List(0.5314795508050395, 0.6254747152242208, 0.3870236094802634, 0.3590652564475848, 0.1350043437170152))
scala> val r2 = ints.run(rng)
r2: (cilib.RNG, List[Int]) = (cilib.CMWC@5dd51dc2,List(-2012280037, -456312394, -1608573853, -1720473833, 1662253751))
scala> r1._2 == r2._2
res1: Boolean = true
```

The result is a tuple of the state of the PRNG after being used in the computation, together with the result of the computation itself. The important point to note is that running the computation again, with the same PRNG, that is the original state of the PRNG *will* result in the same obtained results. Unlike the normal PRNG within the JVM platform, obtaining some random value from the source does not implicitly mutate the PRNG. In order to keep selecting from the PRNG stream, the next state of the PRNG should be passed into subsequent computations, when needed:

```
scala> val (rng2, x) = ints.run(rng)
rng2: cilib.RNG = cilib.CMWC@6a32ad2e
x: List[Int] = List(-2012280037, -456312394, -1608573853, -1720473833, 1662253751)
scala> val (rng3, y) = ints.run(rng2)
rng3: cilib.RNG = cilib.CMWC@11afe3b4
y: List[Int] = List(-973239118, 1542173555, 1984558752, 579839250, 609517835)
scala> x != y
res2: Boolean = true
```

This manual state passing for the PRNG is very cumbersome and as a result, the monad instance of `RVar`

provides this exact functionality to the user, thereby preventing accidental errors due to incorrect usage of PRNG state. Furthermore, the monad instance for `RVar`

allows for cleaner syntax through the use of a `for`

-comprehension as provided by Scala:

```
scala> val composition = for {
| a <- RVar.next[Int] // Get a single Int
| b <- RVar.next[Double] // Get a single Double, using the next state of the PRNG
| c <- RVar.next[Boolean] // Get a Boolean, again passing the PRNG state
| } yield if (c) a*b else b
composition: cilib.RVar[Double] = cilib.RVar$$anon$4@34090e8b
scala> composition.run(rng)
res3: (cilib.RNG, Double) = (cilib.CMWC@4dd4fd79,-1.798488339436242E9)
```

From this definition of how randomness is managed, we can derive several useful algorithms which operate within the `RVar`

computation. Please refer to the scaladoc for more combinators, but some of the more commonly used are illustrated below:

```
scala> val sampleList = NonEmptyList(6,4,5,2,1,3)
sampleList: scalaz.NonEmptyList[Int] = NonEmpty[6,4,5,2,1,3]
scala> RVar.shuffle(sampleList).run(rng)
res4: (cilib.RNG, scalaz.NonEmptyList[Int]) = (cilib.CMWC@76135363,NonEmpty[4,3,5,1,2,6])
scala> RVar.sample(3, sampleList).run(rng)
res5: (cilib.RNG, Option[List[Int]]) = (cilib.CMWC@3f9b2662,Some(List(4, 3, 5)))
```

Building on `RVar`

, we can easily define probability distributions from which, randomness may be sampled. The provided distributions, where standard distributions are also defined, include:

- Uniform
- Gaussian / Normal
- Cauchy
- Gamma
- Exponential
- etc

The interface for the distributions is simply a resulting `RVar`

```
scala> // Use a derived function from monad to repeat an action 'n' times
| Dist.stdNormal.replicateM(5).run(rng)
res7: (cilib.RNG, List[Double]) = (cilib.CMWC@1874fd59,List(0.12471034611540575, 0.10241216207344515, -0.49485286860096944, -2.6592051237450325, 0.7016898748604742))
```