Struct KnowledgeBaseStats

Source

pub struct KnowledgeBaseStats { /* private fields */ }

Expand description

Knowledge base statistics module Tracks queries and letters submitted during learning

Implementations§

Source §

impl KnowledgeBaseStats

Source

pub fn new() -> Self

Creates a new KnowledgeBaseStats instance with all counters at 0

Examples found in repository ?

examples/all_eqtests_custom_kb.rs (line 173)

170    fn new() -> Self {
171        Self {
172            state: ATMState::Idle,
173            stats: KnowledgeBaseStats::new(),
174        }
175    }

More examples

Hide additional examples

examples/custom_kb.rs (line 59)

56    fn new() -> Self {
57        ATMKnowledgeBase {
58            state: ATMState::Idle,
59            stats: KnowledgeBaseStats::new(),
60        }
61    }

examples/vending_machine.rs (line 52)

49    fn new() -> Self {
50        VendingMachineKB {
51            state: VendingState::Idle,
52            stats: KnowledgeBaseStats::new(),
53        }
54    }

examples/benchmark.rs (line 76)

72    fn new() -> Self {
73        Self {
74            transitions: HashMap::new(),
75            current_state: "s0".to_string(),
76            stats: KnowledgeBaseStats::new(),
77        }
78    }

examples/random_walk_eq.rs (line 85)

81    fn new() -> Self {
82        Self {
83            transitions: std::collections::HashMap::new(),
84            current_state: "s0".to_string(),
85            stats: KnowledgeBaseStats::new(),
86        }
87    }

Source

pub fn nb_submitted_query(&self) -> usize

Gets the number of queries submitted to the target

Examples found in repository ?

examples/all_eqtests_custom_kb.rs (line 245)

242    fn from_stats(stats: &KnowledgeBaseStats) -> Self {
243        Self {
244            nb_query: stats.nb_query(),
245            nb_submitted_query: stats.nb_submitted_query(),
246            nb_letter: stats.nb_letter(),
247            nb_submitted_letter: stats.nb_submitted_letter(),
248        }
249    }

Source

pub fn set_nb_submitted_query(&mut self, value: usize)

Sets the number of queries submitted to the target

Source

pub fn increment_nb_submitted_query(&mut self)

Increments the number of queries submitted

Examples found in repository ?

examples/all_eqtests_custom_kb.rs (line 211)

208    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
209        self.stats.increment_nb_query();
210        self.stats.add_nb_letter(query.input_word.len());
211        self.stats.increment_nb_submitted_query();
212        self.stats.add_nb_submitted_letter(query.input_word.len());
213
214        self.state = ATMState::Idle;
215        let mut outputs = Vec::new();
216
217        for input_letter in query.input_word.letters() {
218            let command = input_letter.symbols();
219            let (next_state, response) = self.process_input(command.as_str(), self.state);
220            self.state = next_state;
221            outputs.push(Letter::new(response));
222        }
223
224        query.set_result(Word::from_letters(outputs));
225        Ok(())
226    }

More examples

Hide additional examples

examples/vending_machine.rs (line 78)

75    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
76        self.stats.increment_nb_query();
77        self.stats.add_nb_letter(query.input_word.len());
78        self.stats.increment_nb_submitted_query();
79        self.stats.add_nb_submitted_letter(query.input_word.len());
80
81        // Reset to initial state for each query
82        self.state = VendingState::Idle;
83
84        let mut outputs = Vec::new();
85        for input_letter in query.input_word.letters() {
86            let command_string = input_letter.symbols();
87            let command = command_string.as_str();
88
89            let (next, resp) = self.process_input(command, self.state);
90            self.state = next;
91            outputs.push(Letter::new(resp));
92        }
93
94        query.set_result(Word::from_letters(outputs));
95        Ok(())
96    }

examples/custom_kb.rs (line 97)

94    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
95        self.stats.increment_nb_query();
96        self.stats.add_nb_letter(query.input_word.len());
97        self.stats.increment_nb_submitted_query();
98        self.stats.add_nb_submitted_letter(query.input_word.len());
99        // Reset to initial state for each query
100        self.state = ATMState::Idle;
101
102        // let mut state = self.state.lock().unwrap();
103        let mut outputs = Vec::new();
104
105        for input_letter in query.input_word.letters() {
106            // Extract command from letter name (format: "Letter('x')")
107            let symbol = input_letter.symbols();
108            let command = symbol.as_str();
109
110            let (next_state, response) = self.process_input(command, self.state);
111            self.state = next_state;
112            outputs.push(Letter::new(response));
113        }
114
115        query.set_result(Word::from_letters(outputs));
116        Ok(())
117    }

examples/benchmark.rs (line 92)

89    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
90        self.stats.increment_nb_query();
91        self.stats.add_nb_letter(query.input_word.len());
92        self.stats.increment_nb_submitted_query();
93        self.stats.add_nb_submitted_letter(query.input_word.len());
94
95        self.current_state = "s0".to_string();
96        let mut output_letters = Vec::new();
97
98        for input_letter in query.input_word.letters() {
99            let input = input_letter.symbols();
100            let key = (self.current_state.clone(), input);
101            let (output, next_state) = self
102                .transitions
103                .get(&key)
104                .cloned()
105                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
106
107            output_letters.push(Letter::new(output));
108            self.current_state = next_state;
109        }
110
111        query.set_result(Word::from_letters(output_letters));
112        Ok(())
113    }

examples/random_walk_eq.rs (line 101)

98    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
99        self.stats.increment_nb_query();
100        self.stats.add_nb_letter(query.input_word.len());
101        self.stats.increment_nb_submitted_query();
102        self.stats.add_nb_submitted_letter(query.input_word.len());
103
104        self.current_state = "s0".to_string();
105        let mut output_letters = Vec::new();
106
107        for input_letter in query.input_word.letters() {
108            let input = input_letter.symbols();
109            let key = (self.current_state.clone(), input);
110            let (output, next_state) = self
111                .transitions
112                .get(&key)
113                .cloned()
114                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
115
116            output_letters.push(Letter::new(output));
117            self.current_state = next_state;
118        }
119
120        query.set_result(Word::from_letters(output_letters));
121        Ok(())
122    }

Source

pub fn nb_submitted_letter(&self) -> usize

Gets the number of letters submitted to the target

Examples found in repository ?

examples/all_eqtests_custom_kb.rs (line 247)

242    fn from_stats(stats: &KnowledgeBaseStats) -> Self {
243        Self {
244            nb_query: stats.nb_query(),
245            nb_submitted_query: stats.nb_submitted_query(),
246            nb_letter: stats.nb_letter(),
247            nb_submitted_letter: stats.nb_submitted_letter(),
248        }
249    }

Source

pub fn set_nb_submitted_letter(&mut self, value: usize)

Sets the number of letters submitted to the target

Source

pub fn add_nb_submitted_letter(&mut self, count: usize)

Adds to the number of letters submitted

Examples found in repository ?

examples/all_eqtests_custom_kb.rs (line 212)

208    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
209        self.stats.increment_nb_query();
210        self.stats.add_nb_letter(query.input_word.len());
211        self.stats.increment_nb_submitted_query();
212        self.stats.add_nb_submitted_letter(query.input_word.len());
213
214        self.state = ATMState::Idle;
215        let mut outputs = Vec::new();
216
217        for input_letter in query.input_word.letters() {
218            let command = input_letter.symbols();
219            let (next_state, response) = self.process_input(command.as_str(), self.state);
220            self.state = next_state;
221            outputs.push(Letter::new(response));
222        }
223
224        query.set_result(Word::from_letters(outputs));
225        Ok(())
226    }

More examples

Hide additional examples

examples/vending_machine.rs (line 79)

75    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
76        self.stats.increment_nb_query();
77        self.stats.add_nb_letter(query.input_word.len());
78        self.stats.increment_nb_submitted_query();
79        self.stats.add_nb_submitted_letter(query.input_word.len());
80
81        // Reset to initial state for each query
82        self.state = VendingState::Idle;
83
84        let mut outputs = Vec::new();
85        for input_letter in query.input_word.letters() {
86            let command_string = input_letter.symbols();
87            let command = command_string.as_str();
88
89            let (next, resp) = self.process_input(command, self.state);
90            self.state = next;
91            outputs.push(Letter::new(resp));
92        }
93
94        query.set_result(Word::from_letters(outputs));
95        Ok(())
96    }

examples/custom_kb.rs (line 98)

94    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
95        self.stats.increment_nb_query();
96        self.stats.add_nb_letter(query.input_word.len());
97        self.stats.increment_nb_submitted_query();
98        self.stats.add_nb_submitted_letter(query.input_word.len());
99        // Reset to initial state for each query
100        self.state = ATMState::Idle;
101
102        // let mut state = self.state.lock().unwrap();
103        let mut outputs = Vec::new();
104
105        for input_letter in query.input_word.letters() {
106            // Extract command from letter name (format: "Letter('x')")
107            let symbol = input_letter.symbols();
108            let command = symbol.as_str();
109
110            let (next_state, response) = self.process_input(command, self.state);
111            self.state = next_state;
112            outputs.push(Letter::new(response));
113        }
114
115        query.set_result(Word::from_letters(outputs));
116        Ok(())
117    }

examples/benchmark.rs (line 93)

89    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
90        self.stats.increment_nb_query();
91        self.stats.add_nb_letter(query.input_word.len());
92        self.stats.increment_nb_submitted_query();
93        self.stats.add_nb_submitted_letter(query.input_word.len());
94
95        self.current_state = "s0".to_string();
96        let mut output_letters = Vec::new();
97
98        for input_letter in query.input_word.letters() {
99            let input = input_letter.symbols();
100            let key = (self.current_state.clone(), input);
101            let (output, next_state) = self
102                .transitions
103                .get(&key)
104                .cloned()
105                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
106
107            output_letters.push(Letter::new(output));
108            self.current_state = next_state;
109        }
110
111        query.set_result(Word::from_letters(output_letters));
112        Ok(())
113    }

examples/random_walk_eq.rs (line 102)

98    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
99        self.stats.increment_nb_query();
100        self.stats.add_nb_letter(query.input_word.len());
101        self.stats.increment_nb_submitted_query();
102        self.stats.add_nb_submitted_letter(query.input_word.len());
103
104        self.current_state = "s0".to_string();
105        let mut output_letters = Vec::new();
106
107        for input_letter in query.input_word.letters() {
108            let input = input_letter.symbols();
109            let key = (self.current_state.clone(), input);
110            let (output, next_state) = self
111                .transitions
112                .get(&key)
113                .cloned()
114                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
115
116            output_letters.push(Letter::new(output));
117            self.current_state = next_state;
118        }
119
120        query.set_result(Word::from_letters(output_letters));
121        Ok(())
122    }

Source

pub fn nb_letter(&self) -> usize

Gets the total number of letters triggered while inferring

Examples found in repository ?

examples/all_eqtests_custom_kb.rs (line 246)

242    fn from_stats(stats: &KnowledgeBaseStats) -> Self {
243        Self {
244            nb_query: stats.nb_query(),
245            nb_submitted_query: stats.nb_submitted_query(),
246            nb_letter: stats.nb_letter(),
247            nb_submitted_letter: stats.nb_submitted_letter(),
248        }
249    }

More examples

Hide additional examples

examples/benchmark.rs (line 51)

9fn main() -> Result<(), Box<dyn std::error::Error>> {
10    println!("=== Performance Benchmark ===\n");
11
12    // Create a more complex system to test performance
13    let mut kb = BenchmarkKnowledgeBase::new();
14
15    // Define a 4-state machine with 3 input symbols
16    // This creates a more complex learning scenario
17    kb.add_transition("s0", "a", "0", "s1");
18    kb.add_transition("s0", "b", "1", "s2");
19    kb.add_transition("s0", "c", "0", "s0");
20    
21    kb.add_transition("s1", "a", "1", "s2");
22    kb.add_transition("s1", "b", "0", "s3");
23    kb.add_transition("s1", "c", "1", "s1");
24    
25    kb.add_transition("s2", "a", "0", "s3");
26    kb.add_transition("s2", "b", "1", "s0");
27    kb.add_transition("s2", "c", "0", "s2");
28    
29    kb.add_transition("s3", "a", "1", "s0");
30    kb.add_transition("s3", "b", "0", "s1");
31    kb.add_transition("s3", "c", "1", "s3");
32
33    let knowledge_base = Arc::new(Mutex::new(kb));
34    let vocabulary = vec!["a".to_string(), "b".to_string(), "c".to_string()];
35
36    println!("Learning 4-state automaton with 3-symbol alphabet...\n");
37    
38    let start = Instant::now();
39    let mut lstar = LSTAR::new(vocabulary, knowledge_base.clone(), 6, None, None);
40    let automata = lstar.learn()?;
41    let duration = start.elapsed();
42
43    println!("\n=== Results ===" );
44    println!("Learning time: {:.2?}", duration);
45    println!("States learned: {}", automata.get_states().len());
46    println!("Transitions: {}", automata.transitions.len());
47    
48    let kb_guard = knowledge_base.lock().unwrap();
49    println!("\nQuery Statistics:");
50    println!("  Total queries: {}", kb_guard.stats.nb_query());
51    println!("  Total letters processed: {}", kb_guard.stats.nb_letter());
52    println!("  Avg letters per query: {:.2}", 
53        kb_guard.stats.nb_letter() as f64 / kb_guard.stats.nb_query() as f64);
54
55    println!("\n=== Optimization Benefits ===");
56    println!("✓ Cached transition index: Fast automata playback");
57    println!("✓ SmallVec: Reduced allocations for short words");
58    println!("✓ Enum Letter: Optimized single-symbol storage");
59    println!("✓ HashSet dedup: O(1) query deduplication");
60    println!("✓ Pre-allocated collections: Fewer reallocations");
61
62    Ok(())
63}

Source

pub fn set_nb_letter(&mut self, value: usize)

Sets the total number of letters triggered

Source

pub fn add_nb_letter(&mut self, count: usize)

Adds to the total number of letters triggered

Examples found in repository ?

examples/all_eqtests_custom_kb.rs (line 210)

208    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
209        self.stats.increment_nb_query();
210        self.stats.add_nb_letter(query.input_word.len());
211        self.stats.increment_nb_submitted_query();
212        self.stats.add_nb_submitted_letter(query.input_word.len());
213
214        self.state = ATMState::Idle;
215        let mut outputs = Vec::new();
216
217        for input_letter in query.input_word.letters() {
218            let command = input_letter.symbols();
219            let (next_state, response) = self.process_input(command.as_str(), self.state);
220            self.state = next_state;
221            outputs.push(Letter::new(response));
222        }
223
224        query.set_result(Word::from_letters(outputs));
225        Ok(())
226    }

More examples

Hide additional examples

examples/vending_machine.rs (line 77)

75    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
76        self.stats.increment_nb_query();
77        self.stats.add_nb_letter(query.input_word.len());
78        self.stats.increment_nb_submitted_query();
79        self.stats.add_nb_submitted_letter(query.input_word.len());
80
81        // Reset to initial state for each query
82        self.state = VendingState::Idle;
83
84        let mut outputs = Vec::new();
85        for input_letter in query.input_word.letters() {
86            let command_string = input_letter.symbols();
87            let command = command_string.as_str();
88
89            let (next, resp) = self.process_input(command, self.state);
90            self.state = next;
91            outputs.push(Letter::new(resp));
92        }
93
94        query.set_result(Word::from_letters(outputs));
95        Ok(())
96    }

examples/custom_kb.rs (line 96)

94    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
95        self.stats.increment_nb_query();
96        self.stats.add_nb_letter(query.input_word.len());
97        self.stats.increment_nb_submitted_query();
98        self.stats.add_nb_submitted_letter(query.input_word.len());
99        // Reset to initial state for each query
100        self.state = ATMState::Idle;
101
102        // let mut state = self.state.lock().unwrap();
103        let mut outputs = Vec::new();
104
105        for input_letter in query.input_word.letters() {
106            // Extract command from letter name (format: "Letter('x')")
107            let symbol = input_letter.symbols();
108            let command = symbol.as_str();
109
110            let (next_state, response) = self.process_input(command, self.state);
111            self.state = next_state;
112            outputs.push(Letter::new(response));
113        }
114
115        query.set_result(Word::from_letters(outputs));
116        Ok(())
117    }

examples/benchmark.rs (line 91)

89    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
90        self.stats.increment_nb_query();
91        self.stats.add_nb_letter(query.input_word.len());
92        self.stats.increment_nb_submitted_query();
93        self.stats.add_nb_submitted_letter(query.input_word.len());
94
95        self.current_state = "s0".to_string();
96        let mut output_letters = Vec::new();
97
98        for input_letter in query.input_word.letters() {
99            let input = input_letter.symbols();
100            let key = (self.current_state.clone(), input);
101            let (output, next_state) = self
102                .transitions
103                .get(&key)
104                .cloned()
105                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
106
107            output_letters.push(Letter::new(output));
108            self.current_state = next_state;
109        }
110
111        query.set_result(Word::from_letters(output_letters));
112        Ok(())
113    }

examples/random_walk_eq.rs (line 100)

98    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
99        self.stats.increment_nb_query();
100        self.stats.add_nb_letter(query.input_word.len());
101        self.stats.increment_nb_submitted_query();
102        self.stats.add_nb_submitted_letter(query.input_word.len());
103
104        self.current_state = "s0".to_string();
105        let mut output_letters = Vec::new();
106
107        for input_letter in query.input_word.letters() {
108            let input = input_letter.symbols();
109            let key = (self.current_state.clone(), input);
110            let (output, next_state) = self
111                .transitions
112                .get(&key)
113                .cloned()
114                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
115
116            output_letters.push(Letter::new(output));
117            self.current_state = next_state;
118        }
119
120        query.set_result(Word::from_letters(output_letters));
121        Ok(())
122    }

Source

pub fn nb_query(&self) -> usize

Gets the number of queries triggered while inferring

Examples found in repository ?

examples/all_eqtests_custom_kb.rs (line 244)

242    fn from_stats(stats: &KnowledgeBaseStats) -> Self {
243        Self {
244            nb_query: stats.nb_query(),
245            nb_submitted_query: stats.nb_submitted_query(),
246            nb_letter: stats.nb_letter(),
247            nb_submitted_letter: stats.nb_submitted_letter(),
248        }
249    }

More examples

Hide additional examples

examples/benchmark.rs (line 50)

9fn main() -> Result<(), Box<dyn std::error::Error>> {
10    println!("=== Performance Benchmark ===\n");
11
12    // Create a more complex system to test performance
13    let mut kb = BenchmarkKnowledgeBase::new();
14
15    // Define a 4-state machine with 3 input symbols
16    // This creates a more complex learning scenario
17    kb.add_transition("s0", "a", "0", "s1");
18    kb.add_transition("s0", "b", "1", "s2");
19    kb.add_transition("s0", "c", "0", "s0");
20    
21    kb.add_transition("s1", "a", "1", "s2");
22    kb.add_transition("s1", "b", "0", "s3");
23    kb.add_transition("s1", "c", "1", "s1");
24    
25    kb.add_transition("s2", "a", "0", "s3");
26    kb.add_transition("s2", "b", "1", "s0");
27    kb.add_transition("s2", "c", "0", "s2");
28    
29    kb.add_transition("s3", "a", "1", "s0");
30    kb.add_transition("s3", "b", "0", "s1");
31    kb.add_transition("s3", "c", "1", "s3");
32
33    let knowledge_base = Arc::new(Mutex::new(kb));
34    let vocabulary = vec!["a".to_string(), "b".to_string(), "c".to_string()];
35
36    println!("Learning 4-state automaton with 3-symbol alphabet...\n");
37    
38    let start = Instant::now();
39    let mut lstar = LSTAR::new(vocabulary, knowledge_base.clone(), 6, None, None);
40    let automata = lstar.learn()?;
41    let duration = start.elapsed();
42
43    println!("\n=== Results ===" );
44    println!("Learning time: {:.2?}", duration);
45    println!("States learned: {}", automata.get_states().len());
46    println!("Transitions: {}", automata.transitions.len());
47    
48    let kb_guard = knowledge_base.lock().unwrap();
49    println!("\nQuery Statistics:");
50    println!("  Total queries: {}", kb_guard.stats.nb_query());
51    println!("  Total letters processed: {}", kb_guard.stats.nb_letter());
52    println!("  Avg letters per query: {:.2}", 
53        kb_guard.stats.nb_letter() as f64 / kb_guard.stats.nb_query() as f64);
54
55    println!("\n=== Optimization Benefits ===");
56    println!("✓ Cached transition index: Fast automata playback");
57    println!("✓ SmallVec: Reduced allocations for short words");
58    println!("✓ Enum Letter: Optimized single-symbol storage");
59    println!("✓ HashSet dedup: O(1) query deduplication");
60    println!("✓ Pre-allocated collections: Fewer reallocations");
61
62    Ok(())
63}

Source

pub fn set_nb_query(&mut self, value: usize)

Sets the number of queries triggered

Source

pub fn increment_nb_query(&mut self)

Increments the number of queries triggered

Examples found in repository ?

examples/all_eqtests_custom_kb.rs (line 209)

208    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
209        self.stats.increment_nb_query();
210        self.stats.add_nb_letter(query.input_word.len());
211        self.stats.increment_nb_submitted_query();
212        self.stats.add_nb_submitted_letter(query.input_word.len());
213
214        self.state = ATMState::Idle;
215        let mut outputs = Vec::new();
216
217        for input_letter in query.input_word.letters() {
218            let command = input_letter.symbols();
219            let (next_state, response) = self.process_input(command.as_str(), self.state);
220            self.state = next_state;
221            outputs.push(Letter::new(response));
222        }
223
224        query.set_result(Word::from_letters(outputs));
225        Ok(())
226    }

More examples

Hide additional examples

examples/vending_machine.rs (line 76)

75    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
76        self.stats.increment_nb_query();
77        self.stats.add_nb_letter(query.input_word.len());
78        self.stats.increment_nb_submitted_query();
79        self.stats.add_nb_submitted_letter(query.input_word.len());
80
81        // Reset to initial state for each query
82        self.state = VendingState::Idle;
83
84        let mut outputs = Vec::new();
85        for input_letter in query.input_word.letters() {
86            let command_string = input_letter.symbols();
87            let command = command_string.as_str();
88
89            let (next, resp) = self.process_input(command, self.state);
90            self.state = next;
91            outputs.push(Letter::new(resp));
92        }
93
94        query.set_result(Word::from_letters(outputs));
95        Ok(())
96    }

examples/custom_kb.rs (line 95)

94    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
95        self.stats.increment_nb_query();
96        self.stats.add_nb_letter(query.input_word.len());
97        self.stats.increment_nb_submitted_query();
98        self.stats.add_nb_submitted_letter(query.input_word.len());
99        // Reset to initial state for each query
100        self.state = ATMState::Idle;
101
102        // let mut state = self.state.lock().unwrap();
103        let mut outputs = Vec::new();
104
105        for input_letter in query.input_word.letters() {
106            // Extract command from letter name (format: "Letter('x')")
107            let symbol = input_letter.symbols();
108            let command = symbol.as_str();
109
110            let (next_state, response) = self.process_input(command, self.state);
111            self.state = next_state;
112            outputs.push(Letter::new(response));
113        }
114
115        query.set_result(Word::from_letters(outputs));
116        Ok(())
117    }

examples/benchmark.rs (line 90)

89    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
90        self.stats.increment_nb_query();
91        self.stats.add_nb_letter(query.input_word.len());
92        self.stats.increment_nb_submitted_query();
93        self.stats.add_nb_submitted_letter(query.input_word.len());
94
95        self.current_state = "s0".to_string();
96        let mut output_letters = Vec::new();
97
98        for input_letter in query.input_word.letters() {
99            let input = input_letter.symbols();
100            let key = (self.current_state.clone(), input);
101            let (output, next_state) = self
102                .transitions
103                .get(&key)
104                .cloned()
105                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
106
107            output_letters.push(Letter::new(output));
108            self.current_state = next_state;
109        }
110
111        query.set_result(Word::from_letters(output_letters));
112        Ok(())
113    }

examples/random_walk_eq.rs (line 99)

98    fn resolve_query(&mut self, query: &mut OutputQuery) -> Result<(), String> {
99        self.stats.increment_nb_query();
100        self.stats.add_nb_letter(query.input_word.len());
101        self.stats.increment_nb_submitted_query();
102        self.stats.add_nb_submitted_letter(query.input_word.len());
103
104        self.current_state = "s0".to_string();
105        let mut output_letters = Vec::new();
106
107        for input_letter in query.input_word.letters() {
108            let input = input_letter.symbols();
109            let key = (self.current_state.clone(), input);
110            let (output, next_state) = self
111                .transitions
112                .get(&key)
113                .cloned()
114                .ok_or_else(|| format!("No transition for ({}, {})", key.0, key.1))?;
115
116            output_letters.push(Letter::new(output));
117            self.current_state = next_state;
118        }
119
120        query.set_result(Word::from_letters(output_letters));
121        Ok(())
122    }

Trait Implementations§

Source §

impl Default for KnowledgeBaseStats

Source §

fn default() -> Self

Returns the “default value” for a type. Read more

Source §

impl Display for KnowledgeBaseStats

Source §

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl UnwindSafe for KnowledgeBaseStats

Blanket Implementations§

Source §

impl<T> Any for T
where T: 'static + ?Sized,

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

impl<T> Borrow<T> for T
where T: ?Sized,

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source §

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> IntoEither for T

Source §

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Source §

impl<T> ToString for T
where T: Display + ?Sized,

Source §

fn to_string(&self) -> String

Converts the given value to a String. Read more

Source §

impl<T, U> TryFrom for T
where U: Into<T>,

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct KnowledgeBaseStats Copy item path

Implementations§

impl KnowledgeBaseStats

pub fn new() -> Self

pub fn nb_submitted_query(&self) -> usize

pub fn set_nb_submitted_query(&mut self, value: usize)

pub fn increment_nb_submitted_query(&mut self)

pub fn nb_submitted_letter(&self) -> usize

pub fn set_nb_submitted_letter(&mut self, value: usize)

pub fn add_nb_submitted_letter(&mut self, count: usize)

pub fn nb_letter(&self) -> usize

pub fn set_nb_letter(&mut self, value: usize)

pub fn add_nb_letter(&mut self, count: usize)

pub fn nb_query(&self) -> usize

pub fn set_nb_query(&mut self, value: usize)

pub fn increment_nb_query(&mut self)

Trait Implementations§

impl Default for KnowledgeBaseStats

fn default() -> Self

impl Display for KnowledgeBaseStats

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

Auto Trait Implementations§

impl Freeze for KnowledgeBaseStats

impl RefUnwindSafe for KnowledgeBaseStats

impl Send for KnowledgeBaseStats

impl Sync for KnowledgeBaseStats

impl Unpin for KnowledgeBaseStats

impl UnsafeUnpin for KnowledgeBaseStats

impl UnwindSafe for KnowledgeBaseStats

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> ToString for Twhere T: Display + ?Sized,

fn to_string(&self) -> String

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Struct KnowledgeBaseStats

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T> ToString for T
where T: Display + ?Sized,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,