wasm4pm 26.7.1

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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! ML Utilities — branchless mathematical primitives and feature extraction.

use crate::cache::OwnedColumnarLog;

/// Extract trace lengths as f64 for regression/PCA.
pub fn extract_trace_lengths(col: &OwnedColumnarLog) -> Vec<f64> {
    let mut lengths = Vec::with_capacity(col.trace_offsets.len() - 1);
    for i in 0..col.trace_offsets.len() - 1 {
        lengths.push((col.trace_offsets[i + 1] - col.trace_offsets[i]) as f64);
    }
    lengths
}

/// Compute mean of a slice (branchless sum).
pub fn mean(data: &[f64]) -> f64 {
    if data.is_empty() {
        return 0.0;
    }
    let sum: f64 = data.iter().sum();
    sum / data.len() as f64
}

/// Dot product of two vectors (SIMD-friendly).
pub fn dot_product(a: &[f64], b: &[f64]) -> f64 {
    let n = a.len().min(b.len());
    let a = &a[..n];
    let b = &b[..n];

    let mut sum0 = 0.0;
    let mut sum1 = 0.0;
    let mut sum2 = 0.0;
    let mut sum3 = 0.0;

    let a_chunks = a.chunks_exact(4);
    let b_chunks = b.chunks_exact(4);
    let rem_a = a_chunks.remainder();
    let rem_b = b_chunks.remainder();

    for (ac, bc) in a_chunks.zip(b_chunks) {
        sum0 += ac[0] * bc[0];
        sum1 += ac[1] * bc[1];
        sum2 += ac[2] * bc[2];
        sum3 += ac[3] * bc[3];
    }

    let mut total = sum0 + sum1 + sum2 + sum3;
    for (&x, &y) in rem_a.iter().zip(rem_b.iter()) {
        total += x * y;
    }
    total
}

/// Euclidean distance between two feature vectors (branchless).
pub fn euclidean_distance(a: &[f64], b: &[f64]) -> f64 {
    let n = a.len().min(b.len());
    let a = &a[..n];
    let b = &b[..n];

    let mut sum0 = 0.0;
    let mut sum1 = 0.0;
    let mut sum2 = 0.0;
    let mut sum3 = 0.0;

    let a_chunks = a.chunks_exact(4);
    let b_chunks = b.chunks_exact(4);
    let rem_a = a_chunks.remainder();
    let rem_b = b_chunks.remainder();

    for (ac, bc) in a_chunks.zip(b_chunks) {
        let d0 = ac[0] - bc[0];
        let d1 = ac[1] - bc[1];
        let d2 = ac[2] - bc[2];
        let d3 = ac[3] - bc[3];
        sum0 += d0 * d0;
        sum1 += d1 * d1;
        sum2 += d2 * d2;
        sum3 += d3 * d3;
    }

    let mut total = sum0 + sum1 + sum2 + sum3;
    for (&x, &y) in rem_a.iter().zip(rem_b.iter()) {
        let diff = x - y;
        total += diff * diff;
    }
    total.sqrt()
}

/// Standardizes features (zero mean, unit variance).
pub fn standardize(data: &mut [Vec<f64>]) {
    if data.is_empty() {
        return;
    }
    let num_features = data[0].len();
    let n = data.len() as f64;
    let inv_n = 1.0 / n;

    for j in 0..num_features {
        let mut sum0 = 0.0;
        let mut sum1 = 0.0;
        let mut sum_sq0 = 0.0;
        let mut sum_sq1 = 0.0;

        // Process in chunks of 2 for better pipeline saturation
        let chunks = data.chunks_exact(2);
        let rem = chunks.remainder();

        for c in chunks {
            let v0 = c[0][j];
            let v1 = c[1][j];
            sum0 += v0;
            sum1 += v1;
            sum_sq0 += v0 * v0;
            sum_sq1 += v1 * v1;
        }

        let mut sum = sum0 + sum1;
        let mut sum_sq = sum_sq0 + sum_sq1;

        for r in rem {
            let val = r[j];
            sum += val;
            sum_sq += val * val;
        }

        let mean = sum * inv_n;
        let variance = (sum_sq * inv_n) - (mean * mean);
        let std_dev = variance.sqrt().max(1e-10);
        let inv_std_dev = 1.0 / std_dev;

        for row in data.iter_mut() {
            row[j] = (row[j] - mean) * inv_std_dev;
        }
    }
}