lace 0.9.1

A probabilistic cross-categorization engine
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

use std::convert::TryInto;

use criterion::black_box;
use criterion::criterion_group;
use criterion::criterion_main;
use criterion::BatchSize;
use criterion::Criterion;
use lace::cc::state::Builder;
use lace::codebook::Codebook;
use lace::codebook::ColMetadata;
use lace::codebook::ColMetadataList;
use lace::codebook::ColType;
use lace::data::Datum;
use lace::Engine;
use lace::Row;
use lace::Value;
use lace::WriteMode;
use rand::Rng;
use rand::SeedableRng;
use rand_xoshiro::Xoshiro256Plus;

// build a one-state Engine
fn build_engine(nrows: usize, ncols: usize) -> Engine {
    let coltype = ColType::Continuous {
        hyper: None,
        prior: None,
    };

    // lightly structured view
    let builder = Builder::new()
        .n_rows(nrows)
        .column_configs(ncols, coltype.clone())
        .n_views(2)
        .n_cats(2)
        .seed_from_u64(1337);

    let state = builder.build().unwrap();

    let col_metadata = ColMetadataList::new(
        (0..ncols)
            .map(|id| ColMetadata {
                name: format!("{}", id),
                coltype: coltype.clone(),
                notes: None,
                missing_not_at_random: false,
            })
            .collect(),
    )
    .unwrap();

    let codebook = Codebook {
        table_name: "table".into(),
        state_prior_process: None,
        view_prior_process: None,
        col_metadata,
        comments: None,
        row_names: (0..nrows)
            .map(|ix| format!("{}", ix))
            .collect::<Vec<_>>()
            .try_into()
            .unwrap(),
    };

    Engine {
        states: vec![state],
        state_ids: vec![0],
        codebook,
        rng: Xoshiro256Plus::seed_from_u64(1337),
    }
}

fn build_rows(nrows: usize, ncols: usize) -> Vec<Row<String, String>> {
    let mut rng = rand::rng();
    (0..nrows)
        .map(|row_ix| Row {
            row_ix: format!("{}", row_ix),
            values: (0..ncols)
                .map(|col_ix| Value {
                    col_ix: format!("{}", col_ix),
                    value: Datum::Continuous(rng.random()),
                })
                .collect(),
        })
        .collect()
}

fn bench_overwrite_only(c: &mut Criterion) {
    c.bench_function("insert_data overwrite only", |b| {
        let engine = build_engine(100, 5);
        let rows = build_rows(5, 4);
        b.iter_batched(
            || (engine.clone(), rows.clone()),
            |(mut engine, rows)| {
                let mode = WriteMode::unrestricted();
                black_box(engine.insert_data(rows, None, mode).unwrap());
            },
            BatchSize::LargeInput,
        )
    });
}

fn bench_append_rows(c: &mut Criterion) {
    c.bench_function("insert_data append rows", |b| {
        let engine = build_engine(100, 5);

        let rows: Vec<Row<String, String>> = build_rows(5, 4)
            .drain(..)
            .enumerate()
            .map(|(ix, mut row)| {
                row.row_ix = format!("{}", 100 + ix);
                row
            })
            .collect();

        b.iter_batched(
            || (engine.clone(), rows.clone()),
            |(mut engine, rows)| {
                let mode = WriteMode::unrestricted();
                black_box(engine.insert_data(rows, None, mode).unwrap());
            },
            BatchSize::LargeInput,
        )
    });
}

criterion_group!(insert_data_benches, bench_overwrite_only, bench_append_rows);
criterion_main!(insert_data_benches);