systile 1.0.0

Matmul-native data structures & algorithms: 17 structures (holographic memory, semiring graphs, automata, attention, DFT, Viterbi, k-NN, Bloom, sort, scan, …) whose core operation reduces to a dense matmul, built on a TPU-style tiled tensor with a systolic reference 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

//! Tests for tile-level sparsity detection.

use systile::{Geometry, PaddedTileLattice};

#[test]
fn all_zero_tile_is_detected() {
    let l = PaddedTileLattice::<f32>::zeroed(2, 2, Geometry::TINY).unwrap();
    assert!(l.is_tile_zero(0, 0));
}

#[test]
fn nonzero_tile_is_not_zero() {
    let mut l = PaddedTileLattice::<f32>::zeroed(2, 2, Geometry::TINY).unwrap();
    l.set(0, 0, 1.0).unwrap();
    assert!(!l.is_tile_zero(0, 0));
}

#[test]
fn count_zero_tiles_on_empty() {
    let l = PaddedTileLattice::<f32>::zeroed(4, 8, Geometry::TINY).unwrap();
    assert_eq!(l.count_zero_tiles(), l.num_tiles());
}

#[test]
fn diagonal_leaves_off_diagonal_tiles_zero() {
    let n = 8;
    let mut l = PaddedTileLattice::<f32>::zeroed(n, n, Geometry::TINY).unwrap();
    for i in 0..n {
        l.set(i, i, 1.0).unwrap();
    }
    // Tile grid is (8/2) x (8/4) = 4 x 2 = 8 tiles; the diagonal touches some.
    assert!(l.count_zero_tiles() < l.num_tiles());
    assert!(l.count_zero_tiles() > 0);
}

#[test]
fn nonzero_coords_match_live_tiles() {
    let mut l = PaddedTileLattice::<f32>::zeroed(4, 8, Geometry::TINY).unwrap();
    l.set(0, 0, 1.0).unwrap();
    let coords = l.nonzero_tile_coords();
    assert_eq!(coords, vec![(0, 0)]);
}

#[test]
fn sparsity_is_fraction_of_zero_tiles() {
    let mut l = PaddedTileLattice::<f32>::zeroed(4, 8, Geometry::TINY).unwrap();
    l.set(0, 0, 1.0).unwrap();
    let total = l.num_tiles() as f64;
    let expected = (total - 1.0) / total;
    assert!((l.tile_sparsity() - expected).abs() < 1e-9);
}

#[test]
fn density_complements_sparsity() {
    let mut l = PaddedTileLattice::<f32>::zeroed(4, 8, Geometry::TINY).unwrap();
    l.set(0, 0, 1.0).unwrap();
    assert!((l.tile_density() + l.tile_sparsity() - 1.0).abs() < 1e-9);
}

#[test]
fn fully_dense_has_zero_sparsity() {
    let l = PaddedTileLattice::from_dense(2, 4, &[1.0; 8], Geometry::TINY).unwrap();
    assert_eq!(l.tile_sparsity(), 0.0);
}