alg_tools: comparison src/iterate.rs

-:daf0e3a70c79
+:121cf065e9ed
 max_iter : 100,
 verbose_iter : Verbose::Every(10),
 .. Default::default()
 };
 let mut x = 1 as float;
+# let mut iter_clone = iter.clone();
 iter.iterate(|state|{
 // This is our computational step
 x = x + x.sqrt();
 state.if_verbose(||{
 // return current value when requested
 return x
 })
-})
+});
+// or alternatively (avoiding problems with moves)
+# iter = iter_clone;
+for state in iter.iter() {
+// This is our computational step
+x = x + x.sqrt();
+state.if_verbose(||{
+// return current value when requested
+return x
+})
+}
 ```
 There is no colon after `state.if_verbose`, because we need to return its value. If you do something after the step, you need to store the result in a variable and return it from the main computational step afterwards.
 This will print out
 ```output
 use serde::{Serialize, Deserialize};
 use cpu_time::ProcessTime;
 use std::marker::PhantomData;
 use std::time::Duration;
 use std::error::Error;
+use std::cell::RefCell;
 use std::rc::Rc;
-use std::cell::Cell;
 use crate::types::*;
 use crate::logger::*;
 /// Create the displayed presentation for log items.
 pub trait LogRepr : Debug {
 fn is_quiet(&self) -> bool { false }
 /// Returns an an [`std::iter::Iterator`] that can be used in a `for`-loop.
 fn iter(self) -> AlgIteratorIterator<Self::Iter> {
 AlgIteratorIterator {
-algi : self.prepare(),
+algi : Rc::new(RefCell::new(self.prepare())),
-result : Rc::new(AlgIteratorResponse{
-expected_iter : 0,
-response : Cell::new(Step::Quiet)
-})
 }
 }
 }
 /// Options for [`BasicAlgIteratorFactory`].
 //
 // New for-loop interface
 //
-struct AlgIteratorResponse<I : AlgIterator> {
-expected_iter : usize,
-response : Cell<Step<I::Input, I::State>>,
-}
 pub struct AlgIteratorIterator<I : AlgIterator> {
-algi : I,
+algi : Rc<RefCell<I>>,
-result : Rc<AlgIteratorResponse<I>>,
 }
 pub struct AlgIteratorIteration<I : AlgIterator> {
 state : I::State,
-result : Rc<AlgIteratorResponse<I>>,
+algi : Rc<RefCell<I>>,
-}
-impl<I : AlgIterator> AlgIteratorIterator<I> {
-fn poststep(&mut self, even_if_quiet : bool) {
-let res = self.result.response.take();
-if !even_if_quiet {
-if let Step::Quiet = res {
-return
-}
-}
-self.algi.poststep(res);
-}
 }
 impl<I : AlgIterator> std::iter::Iterator for AlgIteratorIterator<I> {
 type Item = AlgIteratorIteration<I>;
 fn next(&mut self) -> Option<Self::Item> {
-self.poststep(true);
+let algi = self.algi.clone();
-self.algi.prestep().map(|state| AlgIteratorIteration {
+RefCell::borrow_mut(&self.algi).prestep().map(|state| AlgIteratorIteration {
 state,
-result : self.result.clone(),
+algi,
 })
-}
-}
-impl<I : AlgIterator> Drop for AlgIteratorIterator<I> {
-fn drop(&mut self) {
-self.poststep(false)
 }
 }
 /// Types of errors that may occur
 #[derive(Debug,PartialEq,Eq)]
 pub fn if_verbose(self, calc_objective : impl FnMut() -> I::Input) {
 self.if_verbose_check(calc_objective).unwrap()
 }
 /// Version of [`Self::if_verbose`] that propagates errors instead of panicking.
-pub fn if_verbose_check(self, mut calc_objective : impl FnMut() -> I::Input)
+pub fn if_verbose_check(self, calc_objective : impl FnMut() -> I::Input)
 -> Result<(), IterationError> {
-if self.result.expected_iter != self.state.iteration() {
+let mut algi = match RefCell::try_borrow_mut(&self.algi) {
+Err(_) => return Err(IterationError::ReportingOrderingError),
+Ok(algi) => algi
+};
+if self.state.iteration() != algi.iteration() {
 Err(IterationError::ReportingOrderingError)
 } else {
-let res = calc_objective();
+let res : Step<I::Input, I::State, std::convert::Infallible>
-self.result.response.replace(Step::Result(res, self.state));
+= self.state.if_verbose(calc_objective);
+algi.poststep(res);
 Ok(())
 }
 }
 /// Returns the current iteration count.
 .skip(2)
 .step_by(3)
 .collect::<Vec<int>>())
 }
 }
-}
+#[test]
+fn iteration_for_loop() {
+let options = AlgIteratorOptions{
+max_iter : 10,
+verbose_iter : Verbose::Every(3),
+.. Default::default()
+};
+{
+let mut start = 1 as int;
+for state in options.iter() {
+start = start * 2;
+state.if_verbose(|| start)
+}
+assert_eq!(start, (2 as int).pow(10));
+}
+{
+let mut start = 1 as int;
+let mut log = Logger::new();
+let factory = options.instantiate()
+.with_iteration_number()
+.into_log(&mut log);
+for state in factory.iter() {
+start = start * 2;
+state.if_verbose(|| start)
+}
+assert_eq!(start, (2 as int).pow(10));
+assert_eq!(log.data()
+.iter()
+.map(|LogItem{ data : v, iter : _ }| v.clone())
+.collect::<Vec<int>>(),
+(1..10).map(|i| (2 as int).pow(i))
+.skip(2)
+.step_by(3)
+.collect::<Vec<int>>())
+}
+}
+}

Mercurial > repos > alg_tools / file comparison

comparison: src/iterate.rs

src/iterate.rs