wasm4pm 26.6.10

High-performance process mining algorithms in WebAssembly for JavaScript/TypeScript
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! Label replacement utility for POWL models.

use crate::powl_arena::{PowlArena, PowlNode};
use std::collections::HashMap;
use wasm4pm_compat::powl::{ChoiceGraph, ChoiceGraphNode};

/// Replace activity labels in a POWL subtree according to a dictionary.
pub fn apply(
    arena: &PowlArena,
    node_idx: u32,
    label_map: &HashMap<String, String>,
    dest_arena: &mut PowlArena,
) -> u32 {
    match arena.get(node_idx) {
        None => node_idx,

        Some(PowlNode::Transition(t)) => {
            let new_label = t
                .label
                .as_ref()
                .and_then(|l| label_map.get(l).cloned().or_else(|| Some(l.clone())));
            dest_arena.add_transition(new_label)
        }

        Some(PowlNode::FrequentTransition(t)) => {
            let new_activity = label_map
                .get(&t.activity)
                .cloned()
                .unwrap_or_else(|| t.activity.clone());
            dest_arena.add_frequent_transition(new_activity, t.min_freq, t.max_freq)
        }

        Some(PowlNode::OperatorPowl(op)) => {
            let new_children: Vec<u32> = op
                .children
                .iter()
                .map(|&c| apply(arena, c, label_map, dest_arena))
                .collect();
            dest_arena.add_operator(op.operator, new_children)
        }

        Some(PowlNode::StrictPartialOrder(spo)) => {
            let old_children = spo.children.clone();
            let old_order = spo.order.clone();
            let mut new_children: Vec<u32> = Vec::new();
            let n = old_children.len();

            for &c in &old_children {
                new_children.push(apply(arena, c, label_map, dest_arena));
            }

            let spo_idx = dest_arena.add_strict_partial_order(new_children);

            for i in 0..n {
                for j in 0..n {
                    if old_order.is_edge(i, j) {
                        dest_arena.add_order_edge(spo_idx, i, j).ok();
                    }
                }
            }

            spo_idx
        }

        Some(PowlNode::DecisionGraph(dg)) => {
            // Treat as StrictPartialOrder for label replacement purposes
            let old_children = dg.children.clone();
            let old_order = dg.order.clone();
            let mut new_children: Vec<u32> = Vec::new();
            let n = old_children.len();

            for &c in &old_children {
                new_children.push(apply(arena, c, label_map, dest_arena));
            }

            let spo_idx = dest_arena.add_strict_partial_order(new_children);

            for i in 0..n {
                for j in 0..n {
                    if old_order.is_edge(i, j) {
                        dest_arena.add_order_edge(spo_idx, i, j).ok();
                    }
                }
            }

            spo_idx
        }

        Some(PowlNode::ChoiceGraph(cg)) => {
            // Recursively apply label replacement to every SubModel subtree;
            // preserve graph structure (Start/End/edges).
            let mut new_nodes = Vec::with_capacity(cg.graph.nodes.len());
            for n in cg.graph.nodes.clone().into_iter() {
                match n {
                    ChoiceGraphNode::Start => new_nodes.push(ChoiceGraphNode::Start),
                    ChoiceGraphNode::End => new_nodes.push(ChoiceGraphNode::End),
                    ChoiceGraphNode::Activity(l) => {
                        let new_label = label_map.get(l.as_str()).cloned().unwrap_or(l);
                        new_nodes.push(ChoiceGraphNode::Activity(new_label))
                    }
                    ChoiceGraphNode::SubModel(child) => {
                        let new_child = apply(arena, child, label_map, dest_arena);
                        new_nodes.push(ChoiceGraphNode::SubModel(new_child));
                    }
                }
            }
            let new_graph = ChoiceGraph {
                nodes: new_nodes,
                edges: cg.graph.edges.clone(),
                start_idx: cg.graph.start_idx,
                end_idx: cg.graph.end_idx,
            };
            dest_arena.add_choice_graph(&new_graph)
        }
    }
}