Struct SourceTable

Source

pub struct SourceTable { /* private fields */ }

Implementations§

Source §

impl SourceTable

Source

pub fn new() -> SourceTable

Examples found in repository ?

examples/toggle.rs (line 69)

67    pub fn new() -> Toggle {
68        // Every number the program reads, or keeps from one evaluation to the next.
69        let mut table = SourceTable::new();
70        let coordinate = || input(-16_384.0, 16_384.0).grid(1.0 / 64.0);
71        let viewport_width = table.declare("viewport.width", input(0.0, 16_384.0).grid(1.0).initial(1280.0));
72        let viewport_height = table.declare("viewport.height", input(0.0, 16_384.0).grid(1.0).initial(800.0));
73        let mut pointer = |name: &str| Pointer {
74            active: table.declare(format!("{name}.active"), event()),
75            x: table.declare(format!("{name}.x"), coordinate()),
76            y: table.declare(format!("{name}.y"), coordinate()),
77        };
78        let down = pointer("down");
79        let up = pointer("up");
80        let cancel = table.declare("cancel", event());
81        let on_cell = table.declare("on", state_bit());
82        let armed_cell = table.declare("armed", state_bit());
83        let mut circuit = table.create_circuit();
84        let c = &mut circuit;
85
86        // Layout. trackLeft = viewportWidth / 2 - trackWidth / 2
87        let track_left = c.affine(viewport_width * 0.5 - TRACK_WIDTH / 2.0);
88        let track_top = c.affine(viewport_height * 0.5 - TRACK_HEIGHT / 2.0);
89        let track_right = c.affine(track_left + TRACK_WIDTH);
90        let track_bottom = c.affine(track_top + TRACK_HEIGHT);
91        // x >= trackLeft && x < trackLeft + trackWidth && y >= trackTop && y < trackTop + trackHeight
92        let inside_track = |c: &mut Circuit, point: &Pointer| {
93            let bits = [
94                emit_compare(c, point.x, Relation::AtLeast, track_left),
95                emit_compare(c, point.x, Relation::Less, track_right),
96                emit_compare(c, point.y, Relation::AtLeast, track_top),
97                emit_compare(c, point.y, Relation::Less, track_bottom),
98            ];
99            emit_and(c, &bits)
100        };
101
102        // Handle inputs in a fixed order: down, then up, then cancel.
103        // if (down) armed = insideTrack(down)
104        let down_inside = inside_track(c, &down);
105        let armed_after_down = emit_select(c, down.active, armed_cell, down_inside);
106        // if (up && armed && insideTrack(up)) on = !on
107        let up_inside = inside_track(c, &up);
108        let flips = emit_and(c, &[up.active, armed_after_down, up_inside]);
109        let flipped = emit_not(c, on_cell);
110        let on = emit_select(c, flips, on_cell, flipped);
111        // if (up || cancel) armed = false
112        let no_up = emit_not(c, up.active);
113        let no_cancel = emit_not(c, cancel);
114        let armed = emit_and(c, &[armed_after_down, no_up, no_cancel]);
115
116        // Commit state: each state cell gets exactly one next value.
117        table.next(on_cell, on);
118        table.next(armed_cell, armed);
119        table.finish();
120        let outputs = [track_left, track_top, on, armed];
121        let mut roots = outputs.to_vec();
122        roots.extend(table.next_wires());
123        let program = circuit.compile(Some(&roots));
124        let source = table.initial();
125        Toggle {
126            table,
127            circuit,
128            program,
129            source,
130            viewport: (viewport_width, viewport_height),
131            down,
132            up,
133            cancel,
134            outputs,
135        }
136    }

Source

pub fn declare(&mut self, name: impl Into<String>, spec: CellSpec) -> Wire

Declare one cell, returning its wire.

Examples found in repository ?

examples/toggle.rs (line 71)

67    pub fn new() -> Toggle {
68        // Every number the program reads, or keeps from one evaluation to the next.
69        let mut table = SourceTable::new();
70        let coordinate = || input(-16_384.0, 16_384.0).grid(1.0 / 64.0);
71        let viewport_width = table.declare("viewport.width", input(0.0, 16_384.0).grid(1.0).initial(1280.0));
72        let viewport_height = table.declare("viewport.height", input(0.0, 16_384.0).grid(1.0).initial(800.0));
73        let mut pointer = |name: &str| Pointer {
74            active: table.declare(format!("{name}.active"), event()),
75            x: table.declare(format!("{name}.x"), coordinate()),
76            y: table.declare(format!("{name}.y"), coordinate()),
77        };
78        let down = pointer("down");
79        let up = pointer("up");
80        let cancel = table.declare("cancel", event());
81        let on_cell = table.declare("on", state_bit());
82        let armed_cell = table.declare("armed", state_bit());
83        let mut circuit = table.create_circuit();
84        let c = &mut circuit;
85
86        // Layout. trackLeft = viewportWidth / 2 - trackWidth / 2
87        let track_left = c.affine(viewport_width * 0.5 - TRACK_WIDTH / 2.0);
88        let track_top = c.affine(viewport_height * 0.5 - TRACK_HEIGHT / 2.0);
89        let track_right = c.affine(track_left + TRACK_WIDTH);
90        let track_bottom = c.affine(track_top + TRACK_HEIGHT);
91        // x >= trackLeft && x < trackLeft + trackWidth && y >= trackTop && y < trackTop + trackHeight
92        let inside_track = |c: &mut Circuit, point: &Pointer| {
93            let bits = [
94                emit_compare(c, point.x, Relation::AtLeast, track_left),
95                emit_compare(c, point.x, Relation::Less, track_right),
96                emit_compare(c, point.y, Relation::AtLeast, track_top),
97                emit_compare(c, point.y, Relation::Less, track_bottom),
98            ];
99            emit_and(c, &bits)
100        };
101
102        // Handle inputs in a fixed order: down, then up, then cancel.
103        // if (down) armed = insideTrack(down)
104        let down_inside = inside_track(c, &down);
105        let armed_after_down = emit_select(c, down.active, armed_cell, down_inside);
106        // if (up && armed && insideTrack(up)) on = !on
107        let up_inside = inside_track(c, &up);
108        let flips = emit_and(c, &[up.active, armed_after_down, up_inside]);
109        let flipped = emit_not(c, on_cell);
110        let on = emit_select(c, flips, on_cell, flipped);
111        // if (up || cancel) armed = false
112        let no_up = emit_not(c, up.active);
113        let no_cancel = emit_not(c, cancel);
114        let armed = emit_and(c, &[armed_after_down, no_up, no_cancel]);
115
116        // Commit state: each state cell gets exactly one next value.
117        table.next(on_cell, on);
118        table.next(armed_cell, armed);
119        table.finish();
120        let outputs = [track_left, track_top, on, armed];
121        let mut roots = outputs.to_vec();
122        roots.extend(table.next_wires());
123        let program = circuit.compile(Some(&roots));
124        let source = table.initial();
125        Toggle {
126            table,
127            circuit,
128            program,
129            source,
130            viewport: (viewport_width, viewport_height),
131            down,
132            up,
133            cancel,
134            outputs,
135        }
136    }

Source

pub fn len(&self) -> usize

Source

pub fn is_empty(&self) -> bool

Source

pub fn create_circuit(&mut self) -> Circuit

A circuit with every cell’s range, grid and exact-bit declaration.

Examples found in repository ?

examples/toggle.rs (line 83)

67    pub fn new() -> Toggle {
68        // Every number the program reads, or keeps from one evaluation to the next.
69        let mut table = SourceTable::new();
70        let coordinate = || input(-16_384.0, 16_384.0).grid(1.0 / 64.0);
71        let viewport_width = table.declare("viewport.width", input(0.0, 16_384.0).grid(1.0).initial(1280.0));
72        let viewport_height = table.declare("viewport.height", input(0.0, 16_384.0).grid(1.0).initial(800.0));
73        let mut pointer = |name: &str| Pointer {
74            active: table.declare(format!("{name}.active"), event()),
75            x: table.declare(format!("{name}.x"), coordinate()),
76            y: table.declare(format!("{name}.y"), coordinate()),
77        };
78        let down = pointer("down");
79        let up = pointer("up");
80        let cancel = table.declare("cancel", event());
81        let on_cell = table.declare("on", state_bit());
82        let armed_cell = table.declare("armed", state_bit());
83        let mut circuit = table.create_circuit();
84        let c = &mut circuit;
85
86        // Layout. trackLeft = viewportWidth / 2 - trackWidth / 2
87        let track_left = c.affine(viewport_width * 0.5 - TRACK_WIDTH / 2.0);
88        let track_top = c.affine(viewport_height * 0.5 - TRACK_HEIGHT / 2.0);
89        let track_right = c.affine(track_left + TRACK_WIDTH);
90        let track_bottom = c.affine(track_top + TRACK_HEIGHT);
91        // x >= trackLeft && x < trackLeft + trackWidth && y >= trackTop && y < trackTop + trackHeight
92        let inside_track = |c: &mut Circuit, point: &Pointer| {
93            let bits = [
94                emit_compare(c, point.x, Relation::AtLeast, track_left),
95                emit_compare(c, point.x, Relation::Less, track_right),
96                emit_compare(c, point.y, Relation::AtLeast, track_top),
97                emit_compare(c, point.y, Relation::Less, track_bottom),
98            ];
99            emit_and(c, &bits)
100        };
101
102        // Handle inputs in a fixed order: down, then up, then cancel.
103        // if (down) armed = insideTrack(down)
104        let down_inside = inside_track(c, &down);
105        let armed_after_down = emit_select(c, down.active, armed_cell, down_inside);
106        // if (up && armed && insideTrack(up)) on = !on
107        let up_inside = inside_track(c, &up);
108        let flips = emit_and(c, &[up.active, armed_after_down, up_inside]);
109        let flipped = emit_not(c, on_cell);
110        let on = emit_select(c, flips, on_cell, flipped);
111        // if (up || cancel) armed = false
112        let no_up = emit_not(c, up.active);
113        let no_cancel = emit_not(c, cancel);
114        let armed = emit_and(c, &[armed_after_down, no_up, no_cancel]);
115
116        // Commit state: each state cell gets exactly one next value.
117        table.next(on_cell, on);
118        table.next(armed_cell, armed);
119        table.finish();
120        let outputs = [track_left, track_top, on, armed];
121        let mut roots = outputs.to_vec();
122        roots.extend(table.next_wires());
123        let program = circuit.compile(Some(&roots));
124        let source = table.initial();
125        Toggle {
126            table,
127            circuit,
128            program,
129            source,
130            viewport: (viewport_width, viewport_height),
131            down,
132            up,
133            cancel,
134            outputs,
135        }
136    }

Source

pub fn next(&mut self, cell: Wire, value: Wire)

Pair a state cell with the wire that holds its next value.

Examples found in repository ?

examples/toggle.rs (line 117)

67    pub fn new() -> Toggle {
68        // Every number the program reads, or keeps from one evaluation to the next.
69        let mut table = SourceTable::new();
70        let coordinate = || input(-16_384.0, 16_384.0).grid(1.0 / 64.0);
71        let viewport_width = table.declare("viewport.width", input(0.0, 16_384.0).grid(1.0).initial(1280.0));
72        let viewport_height = table.declare("viewport.height", input(0.0, 16_384.0).grid(1.0).initial(800.0));
73        let mut pointer = |name: &str| Pointer {
74            active: table.declare(format!("{name}.active"), event()),
75            x: table.declare(format!("{name}.x"), coordinate()),
76            y: table.declare(format!("{name}.y"), coordinate()),
77        };
78        let down = pointer("down");
79        let up = pointer("up");
80        let cancel = table.declare("cancel", event());
81        let on_cell = table.declare("on", state_bit());
82        let armed_cell = table.declare("armed", state_bit());
83        let mut circuit = table.create_circuit();
84        let c = &mut circuit;
85
86        // Layout. trackLeft = viewportWidth / 2 - trackWidth / 2
87        let track_left = c.affine(viewport_width * 0.5 - TRACK_WIDTH / 2.0);
88        let track_top = c.affine(viewport_height * 0.5 - TRACK_HEIGHT / 2.0);
89        let track_right = c.affine(track_left + TRACK_WIDTH);
90        let track_bottom = c.affine(track_top + TRACK_HEIGHT);
91        // x >= trackLeft && x < trackLeft + trackWidth && y >= trackTop && y < trackTop + trackHeight
92        let inside_track = |c: &mut Circuit, point: &Pointer| {
93            let bits = [
94                emit_compare(c, point.x, Relation::AtLeast, track_left),
95                emit_compare(c, point.x, Relation::Less, track_right),
96                emit_compare(c, point.y, Relation::AtLeast, track_top),
97                emit_compare(c, point.y, Relation::Less, track_bottom),
98            ];
99            emit_and(c, &bits)
100        };
101
102        // Handle inputs in a fixed order: down, then up, then cancel.
103        // if (down) armed = insideTrack(down)
104        let down_inside = inside_track(c, &down);
105        let armed_after_down = emit_select(c, down.active, armed_cell, down_inside);
106        // if (up && armed && insideTrack(up)) on = !on
107        let up_inside = inside_track(c, &up);
108        let flips = emit_and(c, &[up.active, armed_after_down, up_inside]);
109        let flipped = emit_not(c, on_cell);
110        let on = emit_select(c, flips, on_cell, flipped);
111        // if (up || cancel) armed = false
112        let no_up = emit_not(c, up.active);
113        let no_cancel = emit_not(c, cancel);
114        let armed = emit_and(c, &[armed_after_down, no_up, no_cancel]);
115
116        // Commit state: each state cell gets exactly one next value.
117        table.next(on_cell, on);
118        table.next(armed_cell, armed);
119        table.finish();
120        let outputs = [track_left, track_top, on, armed];
121        let mut roots = outputs.to_vec();
122        roots.extend(table.next_wires());
123        let program = circuit.compile(Some(&roots));
124        let source = table.initial();
125        Toggle {
126            table,
127            circuit,
128            program,
129            source,
130            viewport: (viewport_width, viewport_height),
131            down,
132            up,
133            cancel,
134            outputs,
135        }
136    }

Source

pub fn finish(&self)

Check that every state cell has a next value.

Examples found in repository ?

examples/toggle.rs (line 119)

67    pub fn new() -> Toggle {
68        // Every number the program reads, or keeps from one evaluation to the next.
69        let mut table = SourceTable::new();
70        let coordinate = || input(-16_384.0, 16_384.0).grid(1.0 / 64.0);
71        let viewport_width = table.declare("viewport.width", input(0.0, 16_384.0).grid(1.0).initial(1280.0));
72        let viewport_height = table.declare("viewport.height", input(0.0, 16_384.0).grid(1.0).initial(800.0));
73        let mut pointer = |name: &str| Pointer {
74            active: table.declare(format!("{name}.active"), event()),
75            x: table.declare(format!("{name}.x"), coordinate()),
76            y: table.declare(format!("{name}.y"), coordinate()),
77        };
78        let down = pointer("down");
79        let up = pointer("up");
80        let cancel = table.declare("cancel", event());
81        let on_cell = table.declare("on", state_bit());
82        let armed_cell = table.declare("armed", state_bit());
83        let mut circuit = table.create_circuit();
84        let c = &mut circuit;
85
86        // Layout. trackLeft = viewportWidth / 2 - trackWidth / 2
87        let track_left = c.affine(viewport_width * 0.5 - TRACK_WIDTH / 2.0);
88        let track_top = c.affine(viewport_height * 0.5 - TRACK_HEIGHT / 2.0);
89        let track_right = c.affine(track_left + TRACK_WIDTH);
90        let track_bottom = c.affine(track_top + TRACK_HEIGHT);
91        // x >= trackLeft && x < trackLeft + trackWidth && y >= trackTop && y < trackTop + trackHeight
92        let inside_track = |c: &mut Circuit, point: &Pointer| {
93            let bits = [
94                emit_compare(c, point.x, Relation::AtLeast, track_left),
95                emit_compare(c, point.x, Relation::Less, track_right),
96                emit_compare(c, point.y, Relation::AtLeast, track_top),
97                emit_compare(c, point.y, Relation::Less, track_bottom),
98            ];
99            emit_and(c, &bits)
100        };
101
102        // Handle inputs in a fixed order: down, then up, then cancel.
103        // if (down) armed = insideTrack(down)
104        let down_inside = inside_track(c, &down);
105        let armed_after_down = emit_select(c, down.active, armed_cell, down_inside);
106        // if (up && armed && insideTrack(up)) on = !on
107        let up_inside = inside_track(c, &up);
108        let flips = emit_and(c, &[up.active, armed_after_down, up_inside]);
109        let flipped = emit_not(c, on_cell);
110        let on = emit_select(c, flips, on_cell, flipped);
111        // if (up || cancel) armed = false
112        let no_up = emit_not(c, up.active);
113        let no_cancel = emit_not(c, cancel);
114        let armed = emit_and(c, &[armed_after_down, no_up, no_cancel]);
115
116        // Commit state: each state cell gets exactly one next value.
117        table.next(on_cell, on);
118        table.next(armed_cell, armed);
119        table.finish();
120        let outputs = [track_left, track_top, on, armed];
121        let mut roots = outputs.to_vec();
122        roots.extend(table.next_wires());
123        let program = circuit.compile(Some(&roots));
124        let source = table.initial();
125        Toggle {
126            table,
127            circuit,
128            program,
129            source,
130            viewport: (viewport_width, viewport_height),
131            down,
132            up,
133            cancel,
134            outputs,
135        }
136    }

Source

pub fn next_wires(&self) -> Vec<Wire>

The wires the host needs after an evaluation: every state cell’s next value.

Examples found in repository ?

examples/toggle.rs (line 122)

67    pub fn new() -> Toggle {
68        // Every number the program reads, or keeps from one evaluation to the next.
69        let mut table = SourceTable::new();
70        let coordinate = || input(-16_384.0, 16_384.0).grid(1.0 / 64.0);
71        let viewport_width = table.declare("viewport.width", input(0.0, 16_384.0).grid(1.0).initial(1280.0));
72        let viewport_height = table.declare("viewport.height", input(0.0, 16_384.0).grid(1.0).initial(800.0));
73        let mut pointer = |name: &str| Pointer {
74            active: table.declare(format!("{name}.active"), event()),
75            x: table.declare(format!("{name}.x"), coordinate()),
76            y: table.declare(format!("{name}.y"), coordinate()),
77        };
78        let down = pointer("down");
79        let up = pointer("up");
80        let cancel = table.declare("cancel", event());
81        let on_cell = table.declare("on", state_bit());
82        let armed_cell = table.declare("armed", state_bit());
83        let mut circuit = table.create_circuit();
84        let c = &mut circuit;
85
86        // Layout. trackLeft = viewportWidth / 2 - trackWidth / 2
87        let track_left = c.affine(viewport_width * 0.5 - TRACK_WIDTH / 2.0);
88        let track_top = c.affine(viewport_height * 0.5 - TRACK_HEIGHT / 2.0);
89        let track_right = c.affine(track_left + TRACK_WIDTH);
90        let track_bottom = c.affine(track_top + TRACK_HEIGHT);
91        // x >= trackLeft && x < trackLeft + trackWidth && y >= trackTop && y < trackTop + trackHeight
92        let inside_track = |c: &mut Circuit, point: &Pointer| {
93            let bits = [
94                emit_compare(c, point.x, Relation::AtLeast, track_left),
95                emit_compare(c, point.x, Relation::Less, track_right),
96                emit_compare(c, point.y, Relation::AtLeast, track_top),
97                emit_compare(c, point.y, Relation::Less, track_bottom),
98            ];
99            emit_and(c, &bits)
100        };
101
102        // Handle inputs in a fixed order: down, then up, then cancel.
103        // if (down) armed = insideTrack(down)
104        let down_inside = inside_track(c, &down);
105        let armed_after_down = emit_select(c, down.active, armed_cell, down_inside);
106        // if (up && armed && insideTrack(up)) on = !on
107        let up_inside = inside_track(c, &up);
108        let flips = emit_and(c, &[up.active, armed_after_down, up_inside]);
109        let flipped = emit_not(c, on_cell);
110        let on = emit_select(c, flips, on_cell, flipped);
111        // if (up || cancel) armed = false
112        let no_up = emit_not(c, up.active);
113        let no_cancel = emit_not(c, cancel);
114        let armed = emit_and(c, &[armed_after_down, no_up, no_cancel]);
115
116        // Commit state: each state cell gets exactly one next value.
117        table.next(on_cell, on);
118        table.next(armed_cell, armed);
119        table.finish();
120        let outputs = [track_left, track_top, on, armed];
121        let mut roots = outputs.to_vec();
122        roots.extend(table.next_wires());
123        let program = circuit.compile(Some(&roots));
124        let source = table.initial();
125        Toggle {
126            table,
127            circuit,
128            program,
129            source,
130            viewport: (viewport_width, viewport_height),
131            down,
132            up,
133            cancel,
134            outputs,
135        }
136    }

Source

pub fn initial(&self) -> Vec<f32>

Examples found in repository ?

examples/toggle.rs (line 124)

67    pub fn new() -> Toggle {
68        // Every number the program reads, or keeps from one evaluation to the next.
69        let mut table = SourceTable::new();
70        let coordinate = || input(-16_384.0, 16_384.0).grid(1.0 / 64.0);
71        let viewport_width = table.declare("viewport.width", input(0.0, 16_384.0).grid(1.0).initial(1280.0));
72        let viewport_height = table.declare("viewport.height", input(0.0, 16_384.0).grid(1.0).initial(800.0));
73        let mut pointer = |name: &str| Pointer {
74            active: table.declare(format!("{name}.active"), event()),
75            x: table.declare(format!("{name}.x"), coordinate()),
76            y: table.declare(format!("{name}.y"), coordinate()),
77        };
78        let down = pointer("down");
79        let up = pointer("up");
80        let cancel = table.declare("cancel", event());
81        let on_cell = table.declare("on", state_bit());
82        let armed_cell = table.declare("armed", state_bit());
83        let mut circuit = table.create_circuit();
84        let c = &mut circuit;
85
86        // Layout. trackLeft = viewportWidth / 2 - trackWidth / 2
87        let track_left = c.affine(viewport_width * 0.5 - TRACK_WIDTH / 2.0);
88        let track_top = c.affine(viewport_height * 0.5 - TRACK_HEIGHT / 2.0);
89        let track_right = c.affine(track_left + TRACK_WIDTH);
90        let track_bottom = c.affine(track_top + TRACK_HEIGHT);
91        // x >= trackLeft && x < trackLeft + trackWidth && y >= trackTop && y < trackTop + trackHeight
92        let inside_track = |c: &mut Circuit, point: &Pointer| {
93            let bits = [
94                emit_compare(c, point.x, Relation::AtLeast, track_left),
95                emit_compare(c, point.x, Relation::Less, track_right),
96                emit_compare(c, point.y, Relation::AtLeast, track_top),
97                emit_compare(c, point.y, Relation::Less, track_bottom),
98            ];
99            emit_and(c, &bits)
100        };
101
102        // Handle inputs in a fixed order: down, then up, then cancel.
103        // if (down) armed = insideTrack(down)
104        let down_inside = inside_track(c, &down);
105        let armed_after_down = emit_select(c, down.active, armed_cell, down_inside);
106        // if (up && armed && insideTrack(up)) on = !on
107        let up_inside = inside_track(c, &up);
108        let flips = emit_and(c, &[up.active, armed_after_down, up_inside]);
109        let flipped = emit_not(c, on_cell);
110        let on = emit_select(c, flips, on_cell, flipped);
111        // if (up || cancel) armed = false
112        let no_up = emit_not(c, up.active);
113        let no_cancel = emit_not(c, cancel);
114        let armed = emit_and(c, &[armed_after_down, no_up, no_cancel]);
115
116        // Commit state: each state cell gets exactly one next value.
117        table.next(on_cell, on);
118        table.next(armed_cell, armed);
119        table.finish();
120        let outputs = [track_left, track_top, on, armed];
121        let mut roots = outputs.to_vec();
122        roots.extend(table.next_wires());
123        let program = circuit.compile(Some(&roots));
124        let source = table.initial();
125        Toggle {
126            table,
127            circuit,
128            program,
129            source,
130            viewport: (viewport_width, viewport_height),
131            down,
132            up,
133            cancel,
134            outputs,
135        }
136    }

Source

pub fn validate(&self, source: &[f32]) -> Result<(), String>

Check every cell’s range, exact bit and grid.

Examples found in repository ?

examples/toggle.rs (line 165)

148    pub fn step(&mut self, width: f32, height: f32, events: &[PointerEvent]) -> Result<Output, String> {
149        let mut values = self.source.clone();
150        values[self.viewport.0.index()] = width;
151        values[self.viewport.1.index()] = height;
152        for event in events {
153            let pointer = match event.kind {
154                PointerKind::Down => &self.down,
155                PointerKind::Up => &self.up,
156                PointerKind::Cancel => {
157                    values[self.cancel.index()] = 1.0;
158                    continue;
159                }
160            };
161            values[pointer.active.index()] = 1.0;
162            values[pointer.x.index()] = event.x;
163            values[pointer.y.index()] = event.y;
164        }
165        self.table.validate(&values)?;
166        let result = self.circuit.evaluate_tensor(&values, &self.program).map_err(|error| error.to_string())?;
167        self.source = self.table.advance(&values, &result);
168        let [track_left, track_top, on, armed] = self.outputs.map(|wire| result[wire.index()]);
169        Ok(Output { track_left, track_top, on, armed })
170    }

Source

pub fn advance(&self, source: &[f32], values: &[f32]) -> Vec<f32>

The source table for the next evaluation: state cells take their next value, event cells reset to 0, and the rest keep their value.

Examples found in repository ?

examples/toggle.rs (line 167)

148    pub fn step(&mut self, width: f32, height: f32, events: &[PointerEvent]) -> Result<Output, String> {
149        let mut values = self.source.clone();
150        values[self.viewport.0.index()] = width;
151        values[self.viewport.1.index()] = height;
152        for event in events {
153            let pointer = match event.kind {
154                PointerKind::Down => &self.down,
155                PointerKind::Up => &self.up,
156                PointerKind::Cancel => {
157                    values[self.cancel.index()] = 1.0;
158                    continue;
159                }
160            };
161            values[pointer.active.index()] = 1.0;
162            values[pointer.x.index()] = event.x;
163            values[pointer.y.index()] = event.y;
164        }
165        self.table.validate(&values)?;
166        let result = self.circuit.evaluate_tensor(&values, &self.program).map_err(|error| error.to_string())?;
167        self.source = self.table.advance(&values, &result);
168        let [track_left, track_top, on, armed] = self.outputs.map(|wire| result[wire.index()]);
169        Ok(Output { track_left, track_top, on, armed })
170    }