# Random variables¶

SimPype comes with a custom random variable generation system that allows you to generate
random values according to different random distributions depending on the current simulation time.
See `Random`

for a detailed API reference.

```
import simpype
sim = simpype.Simulation(id = 'test')
myrand = simpype.Random(sim, {
initial_time : lambda_function
...
})
```

Where each dictionary element is so defined:

`initial_time`

is the element key and must be ofintorfloattype. It represents the initial simulation time at which the`lambda_function`

is invoked;`lambda_function`

is the element value. It is mandatory that for the value to be alambdafunction. Such function must return a value, usually aintor afloat;

An example of random variable initialization is the following:

```
import simpype
import random
sim = simpype.Simulation(id = 'test')
myrand = simpype.Random(sim, {
# From t=0 to t=10, the random variable returns
# the constant value of 3.0
0 : lambda: 3.0,
# From t=10 to t=20, the random variable returns
# value uniformly distributed between 2.5 and 3.5
10 : lambda: random.uniform(2.5, 3.5),
# From t=20 to t=inf, the random variable returns
# a value exponentially distributed with lambda 0.20
20 : lambda: random.expovariate(0.20)
})
```

To generate a random value:

```
# Simulation time = 5.0
random_value = myrand.value # random_value = 3.0
...
# Simulation time = 15.0
random_value = myrand.value # random_value = 3.2476115513945767
...
# Simulation time = 25.0
random_value = myrand.value # random_value = 7.374759019459148
```

As you can see, depending on the current simulation `myrand.value`

returns a random value according to a different random distribution.

## Generator arrival time¶

The arrival time of a generator is described with a `Random`

variable.

```
import simpype
import random
sim = simpype.Simulation(id = 'simple')
gen0 = sim.add_generator(id = 'gen0')
# Start generating events at a random simulation time
gen0.random['arrival'] = {
# From t=0 to t=10, the arrival time is constant to 3.0
0 : lambda: 3.0,
# From t=10 to t=20, the arrival time is uniformly distributed between 2.5 and 3.5
10 : lambda: random.uniform(2.5, 3.5),
# From t=20 to t=inf, the arrival time is exponentially distributed with lambda 0.20
20 : lambda: random.expovariate(0.20)
}
```

Please note that in this case there is no need of calling the `simpype.Random`

constructor.
The generator object automatically converts the dictionary into a `Random`

object.

## Generation of more than one message at once¶

The number of messages to be generated at any arrival time is described with a `Random`

variable.

```
import simpype
import random
sim = simpype.Simulation(id = 'simple')
gen0 = sim.add_generator(id = 'gen0')
# Arrival time of 1 second
gen0.random['arrival'] = {0: lambda: 1}
# Start generating events at a random simulation time
gen0.random['quantity'] = {
# From t=0 to t=10, 3 messages are generated at once
0 : lambda: 3,
# From t=10 to t=20, a random number of messages (between 1 and 10) is generated at once
10 : lambda: random.randint(1, 10),
# From t=20 to t=inf, 1 message is generated everytime
20 : lambda: 1
}
```

Please note that in this case there is no need of calling the `simpype.Random`

constructor.
The generator object automatically converts the dictionary into a `Random`

object.

## Resource service time¶

The service time of a resource is described with a `Random`

variable.

```
import simpype
import random
sim = simpype.Simulation(id = 'simple')
res0 = sim.add_resource(id = 'res0')
res0.random['arrival'] = {
# From t=0 to t=10, the service time is constant to 3.0
0 : lambda: 3.0,
# From t=10 to t=20, the service time is uniformly distributed between 2.5 and 3.5
10 : lambda: random.uniform(2.5, 3.5),
# From t=20 to t=inf, the service time is exponentially distributed with lambda 0.20
20 : lambda: random.expovariate(0.20)
}
```

Please note that in this case there is no need of calling the `simpype.Random`

constructor.
The resource object automatically converts the dictionary into a `Random`

object.

## Message property¶

A message property can be described with a a `Random`

variable.

```
import simpype
import random
sim = simpype.Simulation(id = 'simple')
gen0 = sim.add_generator(id = 'gen0')
gen0.message.property['test'] = {
# Every message generated between t=0 and t=10 will have the 'test' property value equal to 3.0
0 : lambda: 3.0,
# Every message generated between t=10 and t=20 will have the 'test' property uniformly distributed between 2.5 and 3.5
10 : lambda: random.uniform(2.5, 3.5),
# Every message generated between t=20 and t=inf will have the 'test' property exponentially distributed with lambda 0.20
20 : lambda: random.expovariate(0.20)
}
```

Please note that in this case there is no need of calling the `simpype.Random`

constructor.
The message object automatically converts the dictionary into a `Random`

object.
Please also note that property values can be randomly generated, nevertheless once they are generated they will always return the same value unless an explicit refresh is called

```
message.property['test'].refresh()
```