dvcompute_branch 2.0.0

Discrete event simulation library (nested simulation)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

# dvcompute_branch

This crate is a part of discrete event simulation framework DVCompute Simulator (registration
number 2021660590 of Rospatent). The `dvcompute_branch` crate is destined for nested simulation,
but the same code base is shared by the `dvcompute_dist` crate destined for optimistic
distributed simulation.

There are the following main crates: `dvcompute` (sequential simulation),
`dvcompute_dist` (optimistic distributed simulation),
`dvcompute_cons` (conservative distributed simulation) and
`dvcompute_branch` (nested simulation). All four crates are
very close. They are based on the same method.

## Simulation Method

The main idea is to use continuations for modeling discontinuous processes. Such continuations are
themselves wrapped in the monad, for which there are easy-to-use combinators. This idea is inspired
by two sources: (1) combinators for futures that were in Rust before introducing the async/await 
syntax and (2) the Aivika simulation library that I developed in Haskell before.

Here is an example that defines a model of the machine that breaks down and then it is repaired:

```rust
const UP_TIME_MEAN: f64 = 1.0;
const REPAIR_TIME_MEAN: f64 = 0.5;

fn machine_process(total_up_time: Grc<RefComp<f64>>) -> ProcessBox<()> {
    let total_up_time2 = total_up_time.clone();
    random_exponential_process(UP_TIME_MEAN)
        .and_then(move |up_time| {
            RefComp::modify(total_up_time, move |total_up_time| {
                total_up_time + up_time
            })
            .into_process()
            .and_then(move |()| {
                random_exponential_process_(REPAIR_TIME_MEAN)
            })
            .and_then(move |()| {
                machine_process(total_up_time2)
            })
        })
        .into_boxed()
}
```
 
These computations are combined with help of the monadic bind. Such computations should be run later 
to take effect.

## Examples

You can find examples in the author's [repository](https://gitflic.ru/project/dsorokin/dvcompute).

## Documentation

* [API docs](https://docs.rs/dvcompute_branch/)

## Tutorial

Also you can read the PDF document [DVCompute Simulator Tutorial](https://gitflic.ru/project/dsorokin/dvcompute/blob?file=doc%2Fdvcompute-tutorial.pdf).

## Bibliography

* Sorokin David. DVCompute Simulator for discrete event simulation.
  Prikladnaya informatika=Journal of Applied Informatics, 2021, vol.16, no.3, pp.93-108 (in Russian).
  DOI: 10.37791/2687-0649-2021-16-3-93-108

## Licence

Copyright 2020-2024 David Sorokin <davsor@mail.ru>, based in Yoshkar-Ola, Russia

This software is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at <http://mozilla.org/MPL/2.0/>.