test: Add a test for system that has infinite solutions

src/solver/cuckoo.rs

@@ -437,4 +437,16 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn infinite_solutions() {
+        let f = InfiniteSolutions::default();
+        let dom = f.domain();
+        let eps = convert(1e-12);
+
+        for x in f.initials() {
+            let solver = Cuckoo::new(&f, &dom, thread_rng());
+            assert!(f.is_root(&solve(&f, &dom, solver, x, 25, eps).unwrap(), eps));
+        }
+    }
 }

src/solver/steffensen.rs

@@ -191,4 +191,16 @@ mod tests {
             assert!(f.is_root(&solve(&f, &dom, solver, x, 15, eps).unwrap(), eps));
         }
     }
+
+    #[test]
+    fn infinite_solutions() {
+        let f = InfiniteSolutions::default();
+        let dom = f.domain();
+        let eps = convert(1e-12);
+
+        for x in f.initials() {
+            let solver = Steffensen::new(&f, &dom);
+            assert!(f.is_root(&solve(&f, &dom, solver, x, 25, eps).unwrap(), eps));
+        }
+    }
 }

src/solver/trust_region.rs

@@ -708,4 +708,20 @@ mod tests {
             Err(SolveError::Solver(TrustRegionError::NoProgress)) | Err(SolveError::Termination)
         ));
     }
+
+    #[test]
+    fn infinite_solutions() {
+        let f = InfiniteSolutions::default();
+        let dom = f.domain();
+        let eps = convert(1e-12);
+
+        for x in f.initials() {
+            let solver = TrustRegion::new(&f, &dom);
+            assert!(match solve(&f, &dom, solver, x, 25, eps) {
+                Ok(root) => f.is_root(&root, eps),
+                Err(SolveError::Solver(TrustRegionError::NoValidStep)) => true,
+                Err(error) => panic!("{:?}", error),
+            });
+        }
+    }
 }

src/testing.rs

@@ -543,6 +543,60 @@ impl TestSystem for Exponential {
     }
 }
 
+/// This system is true for any assignment of x.
+#[derive(Debug, Clone, Copy)]
+pub struct InfiniteSolutions {
+    n: usize,
+}
+
+impl InfiniteSolutions {
+    /// Initializes the system with given dimension.
+    pub fn new(n: usize) -> Self {
+        assert!(n > 0, "n must be greater than zero");
+        Self { n }
+    }
+}
+
+impl Default for InfiniteSolutions {
+    fn default() -> Self {
+        Self { n: 1 }
+    }
+}
+
+impl Problem for InfiniteSolutions {
+    type Scalar = f64;
+    type Dim = Dynamic;
+
+    fn dim(&self) -> Self::Dim {
+        Dynamic::from_usize(self.n)
+    }
+}
+
+impl System for InfiniteSolutions {
+    fn eval<Sx, Sfx>(
+        &self,
+        _x: &Vector<Self::Scalar, Self::Dim, Sx>,
+        fx: &mut Vector<Self::Scalar, Self::Dim, Sfx>,
+    ) -> Result<(), ProblemError>
+    where
+        Sx: Storage<Self::Scalar, Self::Dim> + IsContiguous,
+        Sfx: StorageMut<Self::Scalar, Self::Dim>,
+    {
+        for i in 0..self.n {
+            fx[i] = 0.0;
+        }
+
+        Ok(())
+    }
+}
+
+impl TestSystem for InfiniteSolutions {
+    fn initials(&self) -> Vec<OVector<Self::Scalar, Self::Dim>> {
+        let init = DVector::zeros_generic(Dynamic::from_usize(self.n), U1::name());
+        vec![init]
+    }
+}
+
 /// Solving error of the testing solver driver (see [`solve`]).
 #[derive(Debug, Error)]
 pub enum SolveError<E: StdError + 'static> {