Struct TensorProgram 

pub struct TensorProgram {
    pub layers: Vec<TensorLayer>,
    pub roots: Vec<Wire>,
    pub source_size: usize,
    pub value_count: usize,
    pub wire_order: Vec<Wire>,
    pub width: usize,
}

Fields

layers: Vec<TensorLayer>

roots: Vec<Wire>

source_size: usize

value_count: usize

Source cells plus live operations.

wire_order: Vec<Wire>

wire_order[packed] is the wire held at that packed position.

width: usize

The circuit’s width, for full-width results.

Implementations

impl TensorProgram

pub fn stored_weight_count(&self) -> usize

Examples found in repository

examples/toggle.rs (line 216)

fn main() {
    let mut toggle = Toggle::new();
    let program = toggle.program();
    println!(
        "toggle: {} source cells, {} built operations, {} live in {} layers, {} stored weights",
        toggle.circuit().source_size(),
        toggle.circuit().operations().len(),
        program.live_operation_count(),
        program.layers.len(),
        program.stored_weight_count(),
    );
    let press = |kind, x, y| [PointerEvent { kind, x, y }];
    let frames: [(&str, Vec<PointerEvent>); 4] = [
        ("press on the track", press(PointerKind::Down, 640.0, 400.0).to_vec()),
        ("release on the track", press(PointerKind::Up, 640.0, 400.0).to_vec()),
        ("press 1/64 px left of the track", press(PointerKind::Down, 613.984_4, 400.0).to_vec()),
        ("release on the track", press(PointerKind::Up, 640.0, 400.0).to_vec()),
    ];
    for (label, events) in frames {
        let output = toggle.step(1280.0, 800.0, &events).unwrap();
        println!("{label:32} -> on {} armed {}", output.on, output.armed);
    }
}

pub fn live_operation_count(&self) -> usize

Examples found in repository

examples/fizzbuzz.rs (line 25)

fn main() {
    let net = fizzbuzz_circuit();
    println!(
        "fizzbuzz as a ReLU network: {} operations in {} layers",
        net.program.live_operation_count(),
        net.program.layers.len()
    );
    let mut line = Vec::new();
    for n in 1..=100u8 {
        let answer = net.eval(&(n,)).unwrap();
        assert_eq!(answer, fizzbuzz(n), "the network got {n} wrong");
        line.push(match answer {
            3 => "FizzBuzz".to_string(),
            2 => "Buzz".to_string(),
            1 => "Fizz".to_string(),
            _ => n.to_string(),
        });
    }
    println!("{}", line.join(" "));
    println!("100 of 100 correct, with no training.");
}

examples/toggle.rs (line 214)

fn main() {
    let mut toggle = Toggle::new();
    let program = toggle.program();
    println!(
        "toggle: {} source cells, {} built operations, {} live in {} layers, {} stored weights",
        toggle.circuit().source_size(),
        toggle.circuit().operations().len(),
        program.live_operation_count(),
        program.layers.len(),
        program.stored_weight_count(),
    );
    let press = |kind, x, y| [PointerEvent { kind, x, y }];
    let frames: [(&str, Vec<PointerEvent>); 4] = [
        ("press on the track", press(PointerKind::Down, 640.0, 400.0).to_vec()),
        ("release on the track", press(PointerKind::Up, 640.0, 400.0).to_vec()),
        ("press 1/64 px left of the track", press(PointerKind::Down, 613.984_4, 400.0).to_vec()),
        ("release on the track", press(PointerKind::Up, 640.0, 400.0).to_vec()),
    ];
    for (label, events) in frames {
        let output = toggle.step(1280.0, 800.0, &events).unwrap();
        println!("{label:32} -> on {} armed {}", output.on, output.armed);
    }
}

examples/ui_panel.rs (line 137)

fn main() {
    let compiled = ui_frame_circuit();
    let report = compiled.verify(20_000).unwrap();
    eprintln!(
        "ui_frame: {} live operations in {} layers; verified on {} sampled inputs",
        compiled.program.live_operation_count(),
        compiled.program.layers.len(),
        report.checked
    );
    let _ = (TOGGLE, SLIDER_LEFT);
    let mut executor = TensorExecutor::new(&compiled.program);
    let mut source = Vec::new();
    let mut state = (false, false, false, 0u8, 0.0f32);
    println!("frame,x,y,held,pressed,released,on,armed,dragging,level,thumb");
    for (frame, (x, y, pressed, released, held)) in script().into_iter().enumerate() {
        let args = (state.0, state.1, state.2, state.3, state.4, x, y, pressed, released);
        source.clear();
        args.encode(&mut source);
        let outputs = executor.run(&source);
        let next = (outputs[0] == 1.0, outputs[1] == 1.0, outputs[2] == 1.0, outputs[3] as u8, outputs[4]);
        let expected = ui_frame(state.0, state.1, state.2, state.3, state.4, x, y, pressed, released);
        assert_eq!(next, expected, "frame {frame}: the circuit disagrees with ui_frame()");
        state = next;
        println!(
            "{frame},{x},{y},{},{},{},{},{},{},{},{}",
            held as u8, pressed as u8, released as u8, state.0 as u8, state.1 as u8, state.2 as u8, state.3, state.4
        );
    }
}

examples/life.rs (line 39)

fn main() {
    let compiled = life_step_circuit();
    let report = compiled.verify(200).unwrap();
    eprintln!(
        "life_step: {} live operations in {} layers; verified on {} random grids",
        compiled.program.live_operation_count(),
        compiled.program.layers.len(),
        report.checked
    );
    // Two gliders, a lightweight spaceship and an R-pentomino.
    let mut grid = [[false; N]; N];
    for (row, column) in [(1, 2), (2, 3), (3, 1), (3, 2), (3, 3)] {
        grid[row][column] = true;
    }
    for (row, column) in [(14, 4), (15, 5), (16, 3), (16, 4), (16, 5)] {
        grid[row][column] = true;
    }
    for (row, column) in [(4, 14), (4, 17), (5, 18), (6, 14), (6, 18), (7, 15), (7, 16), (7, 17), (7, 18)] {
        grid[row][column] = true;
    }
    for (row, column) in [(16, 16), (16, 17), (17, 15), (17, 16), (18, 16)] {
        grid[row][column] = true;
    }
    let mut executor = TensorExecutor::new(&compiled.program);
    let mut source = Vec::new();
    for generation in 0..120 {
        println!(
            "{}",
            grid.iter().flat_map(|row| row.iter().map(|&alive| if alive { '#' } else { '.' })).collect::<String>()
        );
        source.clear();
        (grid,).encode(&mut source);
        let outputs = executor.run(&source);
        let next: [[bool; N]; N] =
            std::array::from_fn(|row| std::array::from_fn(|column| outputs[row * N + column] == 1.0));
        assert_eq!(next, life_step(grid), "generation {generation}: the circuit disagrees with life_step()");
        grid = next;
    }
}

Trait Implementations

impl Clone for TensorProgram

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TensorProgram

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.