RsBundle  Diff

        }

        /// The variable index is out of bounds.
        InvalidVariable(index: usize, nvars: usize) {
            description("invalid variable")
            display("Variable index out of bounds, got:{} must be < {}", index, nvars)
        }

        /// Iteration limit has been reached.
        IterationLimit(limit: usize) {
            description("iteration limit reached")
            display("The iteration limit of {} has been reached.", limit)
        }
    }
}


/// Result type for solvers.
pub type Result<T> = result::Result<T, Error>;

        self.start_time = Instant::now();

        Ok(())
    }

    /// Solve the problem.
    pub fn solve(&mut self) -> Result<()> {
        try!(self.init());
        for _ in 0..100000 {
        const LIMIT: usize = 10000;
            let mut term = try!(self.step());
            let changed = try!(self.update_problem(term));
            // do not stop if the problem has been changed
            if changed && term == Step::Term {
                term = Step::Null
            }
            self.show_info(term);

        if self.solve_iter(LIMIT)? {
            if term == Step::Term {
                break;
            }
            Ok(())
        } else {
            Err(Error::IterationLimit(LIMIT))
        }
        Ok(())
    }

    /// Solve the problem but stop after `niter` iterations.
    ///
    /// The function returns `Ok(true)` if the termination criterion
    /// has been satisfied. Otherwise it returns `Ok(false)` or an
    /// error code.