tetration 0.1.3

Tetration tensor file format: Rust library (tetration) and tet CLI
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

//! Bulk variance accumulators vs elementwise Welford reference.

use crate::query::fold::reduction::{ReductionKind, ValueAccum, WelfordAccum};

fn var_from(vals: &[f32]) -> f64 {
    let mut acc = ValueAccum::default();
    acc.push_f32_le_bytes(bytemuck::cast_slice(vals), ReductionKind::Var);
    acc.finish_f64(ReductionKind::Var)
}

fn var_elementwise(vals: &[f32]) -> f64 {
    let mut w = WelfordAccum::default();
    for &v in vals {
        w.push(f64::from(v));
    }
    w.population_variance()
}

#[test]
fn bulk_f32_var_matches_elementwise_welford() {
    let vals: Vec<f32> = (0..10_000).map(|i| (i as f32) * 0.001).collect();
    let bulk = var_from(&vals);
    let elem = var_elementwise(&vals);
    assert!((bulk - elem).abs() < 1e-6, "bulk={bulk} elem={elem}");
}

#[test]
fn bulk_f64_var_matches_elementwise_welford() {
    let vals: Vec<f64> = (0..10_000).map(|i| i as f64 * 0.001).collect();
    let mut bulk = ValueAccum::default();
    bulk.push_f64_le_bytes(bytemuck::cast_slice(&vals), ReductionKind::Var);
    let bulk_v = bulk.finish_f64(ReductionKind::Var);

    let mut w = WelfordAccum::default();
    for &v in &vals {
        w.push(v);
    }
    let elem = w.population_variance();
    assert!((bulk_v - elem).abs() < 1e-9, "bulk={bulk_v} elem={elem}");
}

#[test]
fn bulk_i32_var_matches_elementwise_welford() {
    let vals: Vec<i32> = (0..10_000).map(|i| i - 5_000).collect();
    let mut bulk = ValueAccum::default();
    bulk.push_i32_le_bytes(bytemuck::cast_slice(&vals), ReductionKind::Var);
    let bulk_v = bulk.finish_f64(ReductionKind::Var);

    let mut w = WelfordAccum::default();
    for &v in &vals {
        w.push(f64::from(v));
    }
    let elem = w.population_variance();
    assert!((bulk_v - elem).abs() < 1e-6, "bulk={bulk_v} elem={elem}");
}

#[test]
fn bulk_u8_var_matches_elementwise_welford() {
    let vals: Vec<u8> = (0..10_000).map(|i| (i % 256) as u8).collect();
    let mut bulk = ValueAccum::default();
    bulk.push_u8_le_bytes(&vals, ReductionKind::Var);
    let bulk_v = bulk.finish_f64(ReductionKind::Var);

    let mut w = WelfordAccum::default();
    for &v in &vals {
        w.push(f64::from(v));
    }
    let elem = w.population_variance();
    assert!((bulk_v - elem).abs() < 1e-6, "bulk={bulk_v} elem={elem}");
}