pnets_shrunk 0.1.0

A reducer for petri nets
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

use pnets::standard::Net;
use pnets::TransitionId;

use crate::modifications::{Modification, TransitionElimination};
use crate::reducers::reduce::{ConservativeReduce, TransitionReduce};
use crate::reducers::Reduce;

/// Removes redundant transitions which have the same producers and consumers
///
/// See Definition 1, page 5 [STTT](https://doi.org/10.1007/s10009-019-00519-1)
pub struct ParallelTransitionReducer;

impl ConservativeReduce<Net> for ParallelTransitionReducer {}

impl Reduce<Net> for ParallelTransitionReducer {
    fn reduce(net: &mut Net, modifications: &mut Vec<Modification>) {
        for tr in (0..net.transitions.len()).map(|tr| TransitionId::from(tr)) {
            Self::transition_reduce(net, tr, modifications);
        }
    }
}

impl TransitionReduce<Net> for ParallelTransitionReducer {
    fn transition_reduce(net: &mut Net, tr_1: TransitionId, modifications: &mut Vec<Modification>) {
        if !net[tr_1].deleted {
            let mut transitions_to_delete = vec![];
            // Iterate over all connected transition for this transition
            for tr_2 in net[tr_1]
                .produce
                .iter()
                .flat_map(|&(pl, _)| net[pl].produced_by.iter())
                .chain(
                    net[tr_1]
                        .consume
                        .iter()
                        .flat_map(|&(pl, _)| net[pl].produced_by.iter()),
                )
                .map(|(tr, _)| *tr)
                .filter(|&tr_2| {
                    // Search places which are equals to pl_1
                    tr_1 != tr_2
                        && net[tr_1].consume.len() == net[tr_2].consume.len()
                        && net[tr_1].produce.len() == net[tr_2].produce.len()
                        && net[tr_1]
                            .produce
                            .iter_with(&net[tr_2].produce)
                            .all(|(_, w_1, w_2)| w_1 == w_2)
                        && net[tr_1]
                            .consume
                            .iter_with(&net[tr_2].consume)
                            .all(|(_, w_1, w_2)| w_1 == w_2)
                })
            {
                modifications.push(Modification::TransitionElimination(TransitionElimination {
                    deleted_transitions: vec![tr_2],
                }));
                transitions_to_delete.push(tr_2);
            }
            for transition in transitions_to_delete {
                net.delete_transition(transition);
            }
        }
    }
}