Use a reference of problem for set_problem()

src/lib.rs

@@ -115,7 +115,7 @@ mod tests {
         let y = solver.solve(&problem, t).unwrap();
 
         let mut state = OdeSolverState::new(&problem);
-        solver.set_problem(&mut state, problem);
+        solver.set_problem(&mut state, &problem);
         while state.t <= t {
             solver.step(&mut state).unwrap();
         }

src/ode_solver/bdf.rs

@@ -259,9 +259,10 @@ where
     fn problem(&self) -> Option<&OdeSolverProblem<Eqn>> {
         self.ode_problem.as_ref()
     }
-
-    fn set_problem(&mut self, state: &mut OdeSolverState<Eqn::M>, problem: OdeSolverProblem<Eqn>) {
-        self.ode_problem = Some(problem);
+
+    fn set_problem(&mut self, state: &mut OdeSolverState<Eqn::M>, problem: &OdeSolverProblem<Eqn>) {
+        let problem_clone = problem.clone();
+        self.ode_problem = Some(problem_clone);
         let problem = self.ode_problem.as_ref().unwrap();
         let nstates = problem.eqn.nstates();
         self.order = 1usize;

src/ode_solver/mod.rs

@@ -26,13 +26,13 @@ pub mod diffsl;
 
 pub trait OdeSolverMethod<Eqn: OdeEquations> {
     fn problem(&self) -> Option<&OdeSolverProblem<Eqn>>;
-    fn set_problem(&mut self, state: &mut OdeSolverState<Eqn::M>, problem: OdeSolverProblem<Eqn>);
+    fn set_problem(&mut self, state: &mut OdeSolverState<Eqn::M>, problem: &OdeSolverProblem<Eqn>);
     fn step(&mut self, state: &mut OdeSolverState<Eqn::M>) -> Result<()>;
     fn interpolate(&self, state: &OdeSolverState<Eqn::M>, t: Eqn::T) -> Eqn::V;
     fn solve(&mut self, problem: &OdeSolverProblem<Eqn>, t: Eqn::T) -> Result<Eqn::V> {
         let problem = problem.clone();
         let mut state = OdeSolverState::new(&problem);
-        self.set_problem(&mut state, problem);
+        self.set_problem(&mut state, &problem);
         while state.t <= t {
             self.step(&mut state)?;
         }
@@ -46,7 +46,7 @@ pub trait OdeSolverMethod<Eqn: OdeEquations> {
     ) -> Result<Eqn::V> {
         let problem = problem.clone();
         let mut state = OdeSolverState::new_consistent(&problem, root_solver)?;
-        self.set_problem(&mut state, problem);
+        self.set_problem(&mut state, &problem);
         while state.t <= t {
             self.step(&mut state)?;
         }
@@ -254,7 +254,7 @@ mod tests {
         Eqn: OdeEquations<M = M, T = M::T, V = M::V>,
     {
         let mut state = OdeSolverState::new_consistent(&problem, &mut root_solver).unwrap();
-        method.set_problem(&mut state, problem);
+        method.set_problem(&mut state, &problem);
         for point in solution.solution_points.iter() {
             while state.t < point.t {
                 method.step(&mut state).unwrap();