feat!: rename next methods on Solver and Optimizer so they do not clash

examples/rosenbrock.rs

@@ -43,7 +43,7 @@ fn main() -> Result<(), String> {
 
  for i in 1..=100 {
  solver
- .next(&f, &dom, &mut x, &mut fx)
+ .solve_next(&f, &dom, &mut x, &mut fx)
  .map_err(|err| format!("{}", err))?;
 
  println!(

gomez-bench/benches/main.rs

@@ -184,7 +184,7 @@ where
  let mut fx = x.clone_owned();
  let mut iter = 0;
  loop {
- if solver.next(&f, &dom, &mut x, &mut fx).is_err() {
+ if solver.solve_next(&f, &dom, &mut x, &mut fx).is_err() {
  panic!("solver error");
  }
 
@@ -290,7 +290,7 @@ impl<F: TestSystem<Scalar = f64>> Solver<F> for GslSolverWrapper<GslFunctionWrap
 
  type Error = String;
 
- fn next<Sx, Sfx>(
+ fn solve_next<Sx, Sfx>(
  &mut self,
  _f: &F,
  _dom: &Domain<F::Scalar>,

src/core/optimizer.rs

@@ -5,7 +5,7 @@ use super::{domain::Domain, function::Function};
 /// Common interface for all optimizers.
 ///
 /// All optimizers implement a common interface defined by the [`Optimizer`]
-/// trait. The essential method is [`next`](Optimizer::next) which takes
+/// trait. The essential method is [`opt_next`](Optimizer::opt_next) which takes
 /// variables *x* and computes the next step. Thus it represents one iteration
 /// in the process. Repeated call to this method should move *x* towards the
 /// minimum in successful cases.
@@ -44,7 +44,7 @@ use super::{domain::Domain, function::Function};
 /// const NAME: &'static str = "Random";
 /// type Error = std::convert::Infallible;
 ///
-/// fn next<Sx>(
+/// fn opt_next<Sx>(
 /// &mut self,
 /// f: &F,
 /// dom: &Domain<F::Scalar>,
@@ -82,7 +82,7 @@ pub trait Optimizer<F: Function> {
  /// The implementations *can* assume that subsequent calls to `next` pass
  /// the value of `x` as was outputted in the previous iteration by the same
  /// method.
- fn next<Sx>(
+ fn opt_next<Sx>(
  &mut self,
  f: &F,
  dom: &Domain<F::Scalar>,

src/core/solver.rs

@@ -5,10 +5,10 @@ use super::{domain::Domain, system::System};
 /// Common interface for all solvers.
 ///
 /// All solvers implement a common interface defined by the [`Solver`] trait.
-/// The essential method is [`next`](Solver::next) which takes variables *x* and
-/// computes the next step. Thus it represents one iteration in the process.
-/// Repeated call to this method should converge *x* to the solution in
-/// successful cases.
+/// The essential method is [`solve_next`](Solver::solve_next) which takes
+/// variables *x* and computes the next step. Thus it represents one iteration
+/// in the process. Repeated call to this method should converge *x* to the
+/// solution in successful cases.
 ///
 /// If you implement a solver, please consider make it a contribution to this
 /// library.
@@ -44,7 +44,7 @@ use super::{domain::Domain, system::System};
 /// const NAME: &'static str = "Random";
 /// type Error = std::convert::Infallible;
 ///
-/// fn next<Sx, Sfx>(
+/// fn solve_next<Sx, Sfx>(
 /// &mut self,
 /// f: &F,
 /// dom: &Domain<F::Scalar>,
@@ -86,7 +86,7 @@ pub trait Solver<F: System> {
  /// The implementations *can* assume that subsequent calls to `next` pass
  /// the value of `x` as was outputted in the previous iteration by the same
  /// method.
- fn next<Sx, Sfx>(
+ fn solve_next<Sx, Sfx>(
  &mut self,
  f: &F,
  dom: &Domain<F::Scalar>,

src/lib.rs

@@ -192,7 +192,7 @@
 //! for i in 1.. {
 //! // Do one iteration in the solving process.
 //! solver
-//! .next(&f, &dom, &mut x, &mut fx)
+//! .solve_next(&f, &dom, &mut x, &mut fx)
 //! .expect("solver encountered an error");
 //!
 //! println!(

src/solver/lipo.rs

@@ -350,7 +350,7 @@ where
 
  // Do not fail the optimization on an error from the local
  // optimization.
- match local_optimizer.next(f, dom, x) {
+ match local_optimizer.opt_next(f, dom, x) {
  Ok(error) => error,
  Err(_) => f.apply(x),
  }
@@ -387,7 +387,7 @@ where
 
  type Error = LipoError;
 
- fn next<Sx>(
+ fn opt_next<Sx>(
  &mut self,
  f: &F,
  dom: &Domain<<F>::Scalar>,
@@ -409,7 +409,7 @@ where
 
  type Error = LipoError;
 
- fn next<Sx, Sfx>(
+ fn solve_next<Sx, Sfx>(
  &mut self,
  f: &F,
  dom: &Domain<<F>::Scalar>,

src/solver/nelder_mead.rs

@@ -457,7 +457,7 @@ impl<F: Function> Optimizer<F> for NelderMead<F> {
 
  type Error = NelderMeadError;
 
- fn next<Sx>(
+ fn opt_next<Sx>(
  &mut self,
  f: &F,
  dom: &Domain<F::Scalar>,
@@ -475,7 +475,7 @@ impl<F: System + Function> Solver<F> for NelderMead<F> {
 
  type Error = NelderMeadError;
 
- fn next<Sx, Sfx>(
+ fn solve_next<Sx, Sfx>(
  &mut self,
  f: &F,
  dom: &Domain<F::Scalar>,

src/solver/steffensen.rs

@@ -84,7 +84,7 @@ impl<F: System> Solver<F> for Steffensen<F> {
 
  type Error = SteffensenError;
 
- fn next<Sx, Sfx>(
+ fn solve_next<Sx, Sfx>(
  &mut self,
  f: &F,
  dom: &Domain<F::Scalar>,

src/solver/trust_region.rs

@@ -203,7 +203,7 @@ impl<F: System> Solver<F> for TrustRegion<F> {
 
  type Error = TrustRegionError;
 
- fn next<Sx, Sfx>(
+ fn solve_next<Sx, Sfx>(
  &mut self,
  f: &F,
  dom: &Domain<F::Scalar>,
@@ -685,7 +685,7 @@ impl<F: Function> Optimizer<F> for TrustRegion<F> {
 
  type Error = TrustRegionError;
 
- fn next<Sx>(
+ fn opt_next<Sx>(
  &mut self,
  f: &F,
  dom: &Domain<<F>::Scalar>,

src/testing.rs

@@ -737,7 +737,7 @@ where
  let mut iter = 0;
 
  loop {
- solver.next(f, dom, &mut x, &mut fx)?;
+ solver.solve_next(f, dom, &mut x, &mut fx)?;
 
  if fx.norm() <= tolerance {
  return Ok(x);
@@ -767,7 +767,7 @@ where
  let mut iter = 0;
 
  loop {
- let fx = optimizer.next(f, dom, &mut x)?;
+ let fx = optimizer.opt_next(f, dom, &mut x)?;
 
  if fx <= min + tolerance {
  // Converged.
@@ -799,7 +799,7 @@ where
  let mut fx = x.clone_owned();
 
  for iter in 0..iters {
- solver.next(f, dom, &mut x, &mut fx)?;
+ solver.solve_next(f, dom, &mut x, &mut fx)?;
  inspect(&solver, &x, fx.norm(), iter);
  }