Disable execution counting by default

Author: pacak

crates/argmin/src/core/executor.rs

@@ -313,6 +313,8 @@ where
         mode: ObserverMode,
     ) -> Self {
         self.observers.push(observer, mode);
+        let state = self.state.take().unwrap();
+        self.state = Some(state.set_counting(true));
         self.timer = true;
         self
     }

crates/argmin/src/core/state/iterstate.rs

@@ -82,6 +82,8 @@ pub struct IterState<P, G, J, H, R, F> {
     pub max_iters: u64,
     /// Evaluation counts
     pub counts: HashMap<String, u64>,
+    /// Update evaluation counts?
+    pub counting_enabled: bool,
     /// Time required so far
     pub time: Option<instant::Duration>,
     /// Status of optimization execution
@@ -1040,6 +1042,7 @@ where
             last_best_iter: 0,
             max_iters: std::u64::MAX,
             counts: HashMap::new(),
+            counting_enabled: false,
             time: Some(instant::Duration::new(0, 0)),
             termination_status: TerminationStatus::NotTerminated,
         }
@@ -1339,7 +1342,7 @@ where
     /// ```
     /// # use std::collections::HashMap;
     /// # use argmin::core::{Problem, IterState, State, ArgminFloat};
-    /// # let mut state: IterState<Vec<f64>, (), (), (), (), f64> = IterState::new();
+    /// # let mut state: IterState<Vec<f64>, (), (), (), (), f64> = IterState::new().set_counting(true);
     /// # assert_eq!(state.counts, HashMap::new());
     /// # state.counts.insert("test2".to_string(), 10u64);
     /// #
@@ -1356,9 +1359,11 @@ where
     /// # assert_eq!(state.counts, hm);
     /// ```
     fn func_counts<O>(&mut self, problem: &Problem<O>) {
-        for (k, &v) in problem.counts.iter() {
-            let count = self.counts.entry(k.to_string()).or_insert(0);
-            *count = v
+        if self.counting_enabled {
+            for (k, &v) in problem.counts.iter() {
+                let count = self.counts.entry(k.to_string()).or_insert(0);
+                *count = v
+            }
         }
     }
 
@@ -1401,6 +1406,13 @@ where
     fn is_best(&self) -> bool {
         self.last_best_iter == self.iter
     }
+
+    /// Overrides state of counting function executions, by default - only if needed
+    #[must_use]
+    fn set_counting(mut self, mode: bool) -> Self {
+        self.counting_enabled = mode;
+        self
+    }
 }
 
 #[cfg(test)]

crates/argmin/src/core/state/linearprogramstate.rs

@@ -57,6 +57,8 @@ pub struct LinearProgramState<P, F> {
     pub max_iters: u64,
     /// Evaluation counts
     pub counts: HashMap<String, u64>,
+    /// Update evaluation counts?
+    pub counting_enabled: bool,
     /// Time required so far
     pub time: Option<instant::Duration>,
     /// Status of optimization execution
@@ -206,6 +208,7 @@ where
             last_best_iter: 0,
             max_iters: std::u64::MAX,
             counts: HashMap::new(),
+            counting_enabled: false,
             time: Some(instant::Duration::new(0, 0)),
             termination_status: TerminationStatus::NotTerminated,
         }
@@ -504,7 +507,7 @@ where
     /// ```
     /// # use std::collections::HashMap;
     /// # use argmin::core::{Problem, LinearProgramState, State, ArgminFloat};
-    /// # let mut state: LinearProgramState<Vec<f64>, f64> = LinearProgramState::new();
+    /// # let mut state: LinearProgramState<Vec<f64>, f64> = LinearProgramState::new().set_counting(true);
     /// # assert_eq!(state.counts, HashMap::new());
     /// # state.counts.insert("test2".to_string(), 10u64);
     /// #
@@ -521,9 +524,11 @@ where
     /// # assert_eq!(state.counts, hm);
     /// ```
     fn func_counts<O>(&mut self, problem: &Problem<O>) {
-        for (k, &v) in problem.counts.iter() {
-            let count = self.counts.entry(k.to_string()).or_insert(0);
-            *count = v
+        if self.counting_enabled {
+            for (k, &v) in problem.counts.iter() {
+                let count = self.counts.entry(k.to_string()).or_insert(0);
+                *count = v
+            }
         }
     }
 
@@ -566,4 +571,11 @@ where
     fn is_best(&self) -> bool {
         self.last_best_iter == self.iter
     }
+
+    /// Overrides state of counting function executions, by default - only if needed
+    #[must_use]
+    fn set_counting(mut self, mode: bool) -> Self {
+        self.counting_enabled = mode;
+        self
+    }
 }

crates/argmin/src/core/state/mod.rs

@@ -90,6 +90,9 @@ pub trait State {
     /// Returns current cost function evaluation count
     fn get_func_counts(&self) -> &HashMap<String, u64>;
 
+    /// Set function counting status
+    fn set_counting(self, mode: bool) -> Self;
+
     /// Set time required since the beginning of the optimization until the current iteration
     fn time(&mut self, time: Option<instant::Duration>) -> &mut Self;
 

crates/argmin/src/core/state/populationstate.rs

@@ -59,6 +59,8 @@ pub struct PopulationState<P, F> {
     pub max_iters: u64,
     /// Evaluation counts
     pub counts: HashMap<String, u64>,
+    /// Update evaluation counts?
+    pub counting_enabled: bool,
     /// Time required so far
     pub time: Option<instant::Duration>,
     /// Status of optimization execution
@@ -484,6 +486,7 @@ where
             last_best_iter: 0,
             max_iters: std::u64::MAX,
             counts: HashMap::new(),
+            counting_enabled: false,
             time: Some(instant::Duration::new(0, 0)),
             termination_status: TerminationStatus::NotTerminated,
         }
@@ -783,7 +786,7 @@ where
     /// ```
     /// # use std::collections::HashMap;
     /// # use argmin::core::{Problem, PopulationState, State, ArgminFloat};
-    /// # let mut state: PopulationState<Vec<f64>, f64> = PopulationState::new();
+    /// # let mut state: PopulationState<Vec<f64>, f64> = PopulationState::new().set_counting(true);
     /// # assert_eq!(state.counts, HashMap::new());
     /// # state.counts.insert("test2".to_string(), 10u64);
     /// #
@@ -800,9 +803,11 @@ where
     /// # assert_eq!(state.counts, hm);
     /// ```
     fn func_counts<O>(&mut self, problem: &Problem<O>) {
-        for (k, &v) in problem.counts.iter() {
-            let count = self.counts.entry(k.to_string()).or_insert(0);
-            *count = v
+        if self.counting_enabled {
+            for (k, &v) in problem.counts.iter() {
+                let count = self.counts.entry(k.to_string()).or_insert(0);
+                *count = v
+            }
         }
     }
 
@@ -845,6 +850,12 @@ where
     fn is_best(&self) -> bool {
         self.last_best_iter == self.iter
     }
+
+    /// Overrides state of counting function executions, by default - only if needed
+    fn set_counting(mut self, mode: bool) -> Self {
+        self.counting_enabled = mode;
+        self
+    }
 }
 
 // TODO: Tests? Actually doc tests should already cover everything.

crates/argmin/src/solver/brent/brentopt.rs

@@ -230,7 +230,7 @@ mod tests {
         let cost = TestFunc {};
         let solver = BrentOpt::new(-10., 10.);
         let res = Executor::new(cost, solver)
-            .configure(|state| state.max_iters(13))
+            .configure(|state| state.set_counting(true).max_iters(13))
             .run()
             .unwrap();
         assert_eq!(

crates/argmin/src/solver/linesearch/backtracking.rs

@@ -640,7 +640,12 @@ mod tests {
         ls.search_direction(vec![2.0f64, 0.0]);
 
         let data = Executor::new(prob, ls.clone())
-            .configure(|config| config.param(ls.init_param.clone().unwrap()).max_iters(10))
+            .configure(|config| {
+                config
+                    .set_counting(true)
+                    .param(ls.init_param.clone().unwrap())
+                    .max_iters(10)
+            })
             .run();
         assert!(data.is_ok());
 
@@ -689,7 +694,12 @@ mod tests {
         ls.search_direction(vec![2.0f64, 0.0]);
 
         let data = Executor::new(prob, ls.clone())
-            .configure(|config| config.param(ls.init_param.clone().unwrap()).max_iters(10))
+            .configure(|config| {
+                config
+                    .set_counting(true)
+                    .param(ls.init_param.clone().unwrap())
+                    .max_iters(10)
+            })
             .run();
         assert!(data.is_ok());