fix clippy issues

Author: alphaville

src/alm/alm_factory.rs

@@ -260,20 +260,20 @@ where
             f1_u_plus_y_over_c
                 .iter_mut()
                 .zip(y_lagrange_mult.iter())
-                .for_each(|(ti, yi)| *ti = *ti + *yi / penalty_scale);
+                .for_each(|(ti, yi)| *ti += *yi / penalty_scale);
             s.copy_from_slice(&f1_u_plus_y_over_c);
             set_c.project(&mut s);
             let dist_sq: T = matrix_operations::norm2_squared_diff(&f1_u_plus_y_over_c, &s);
             let scaling: T = half::<T>() * penalty_parameter;
-            *cost = *cost + scaling * dist_sq;
+            *cost += scaling * dist_sq;
         }
         if let Some(f2) = &self.mapping_f2 {
             let c = xi[0];
             let mut z = vec![T::zero(); self.n2];
             f2(u, &mut z)?;
             let norm_sq: T = matrix_operations::norm2_squared(&z);
             let scaling: T = half::<T>() * c;
-            *cost = *cost + scaling * norm_sq;
+            *cost += scaling * norm_sq;
         }
         Ok(())
     }
@@ -325,7 +325,7 @@ where
             f1_u_plus_y_over_c
                 .iter_mut()
                 .zip(y_lagrange_mult.iter())
-                .for_each(|(ti, yi)| *ti = *ti + *yi / c_penalty_parameter);
+                .for_each(|(ti, yi)| *ti += *yi / c_penalty_parameter);
             s_aux_var.copy_from_slice(&f1_u_plus_y_over_c); // s = t
             set_c.project(&mut s_aux_var); // s = Proj_C(F1(u) + y/c)
 
@@ -340,7 +340,7 @@ where
             // grad += c*t
             grad.iter_mut()
                 .zip(jac_prod.iter())
-                .for_each(|(gradi, jac_prodi)| *gradi = *gradi + c_penalty_parameter * *jac_prodi);
+                .for_each(|(gradi, jac_prodi)| *gradi += c_penalty_parameter * *jac_prodi);
         }
 
         // Compute second part: JF2(u)'*F2(u)
@@ -354,7 +354,7 @@ where
 
             // grad += c * jf2u_times_f2u_aux
             grad.iter_mut().zip(jf2u_times_f2u_aux.iter()).for_each(
-                |(gradi, jf2u_times_f2u_aux_i)| *gradi = *gradi + c * *jf2u_times_f2u_aux_i,
+                |(gradi, jf2u_times_f2u_aux_i)| *gradi += c * *jf2u_times_f2u_aux_i,
             );
         }
         Ok(())

src/alm/alm_optimizer.rs

@@ -1027,21 +1027,27 @@ mod tests {
         FunctionCallResult,
     };
 
+    type DummyParametricGradient = fn(&[f64], &[f64], &mut [f64]) -> FunctionCallResult;
+    type DummyParametricCost = fn(&[f64], &[f64], &mut f64) -> FunctionCallResult;
+    type DummyMapping = MappingType;
+    type DummyConstraint = Ball2<'static>;
+    type DummyAlmProblem = AlmProblem<
+        DummyMapping,
+        DummyMapping,
+        DummyParametricGradient,
+        DummyParametricCost,
+        DummyConstraint,
+        DummyConstraint,
+        DummyConstraint,
+    >;
+
     fn make_dummy_alm_problem(
         n1: usize,
         n2: usize,
-    ) -> AlmProblem<
-        impl Fn(&[f64], &mut [f64]) -> FunctionCallResult,
-        impl Fn(&[f64], &mut [f64]) -> FunctionCallResult,
-        impl Fn(&[f64], &[f64], &mut [f64]) -> FunctionCallResult,
-        impl Fn(&[f64], &[f64], &mut f64) -> FunctionCallResult,
-        impl Constraint,
-        impl Constraint,
-        impl Constraint,
-    > {
+    ) -> DummyAlmProblem {
         // Main problem data
-        let psi = void_parameteric_cost;
-        let d_psi = void_parameteric_gradient;
+        let psi: DummyParametricCost = void_parameteric_cost;
+        let d_psi: DummyParametricGradient = void_parameteric_gradient;
         let bounds = Ball2::new(None, 10.0);
         // ALM-type data
         let f1: Option<MappingType> = if n1 == 0 {
@@ -1085,7 +1091,7 @@ mod tests {
 
         // Test: with_initial_penalty
         let alm_optimizer = alm_optimizer.with_initial_penalty(7.0);
-        assert!(!alm_optimizer.alm_cache.xi.is_none());
+        assert!(alm_optimizer.alm_cache.xi.is_some());
         if let Some(xi) = &alm_optimizer.alm_cache.xi {
             unit_test_utils::assert_nearly_equal(
                 7.0,

src/cholesky_factorizer.rs

@@ -241,12 +241,7 @@ mod tests {
         let _ = factorizer.factorize(&a);
         assert!(3 == factorizer.dimension(), "wrong dimension");
         let expected_l = [2.0, 0.0, 0.0, 6.0, 1.0, 0.0, -8.0, 5.0, 3.0];
-        unit_test_utils::nearly_equal_array(
-            &expected_l,
-            &factorizer.cholesky_factor(),
-            1e-10,
-            1e-12,
-        );
+        unit_test_utils::nearly_equal_array(&expected_l, factorizer.cholesky_factor(), 1e-10, 1e-12);
     }
 
     #[test]

src/constraints/tests.rs

@@ -177,8 +177,8 @@ fn t_finite_set_project_wrong_dimension() {
 
 #[test]
 fn t_rectangle_bounded() {
-    let xmin = vec![2.0; 5];
-    let xmax = vec![4.5; 5];
+    let xmin = [2.0; 5];
+    let xmax = [4.5; 5];
     let rectangle = Rectangle::new(Some(&xmin[..]), Some(&xmax[..]));
     let mut x = [1.0, 2.0, 3.0, 4.0, 5.0];
 
@@ -195,8 +195,8 @@ fn t_rectangle_bounded() {
 
 #[test]
 fn t_rectangle_bounded_f32() {
-    let xmin = vec![2.0_f32; 3];
-    let xmax = vec![4.5_f32; 3];
+    let xmin = [2.0_f32; 3];
+    let xmax = [4.5_f32; 3];
     let rectangle = Rectangle::new(Some(&xmin[..]), Some(&xmax[..]));
     let mut x = [1.0_f32, 3.0, 5.0];
 
@@ -226,8 +226,8 @@ fn t_rectangle_infinite_bounds() {
 #[test]
 #[should_panic]
 fn t_rectangle_incompatible_dims() {
-    let xmin = vec![1.0; 5];
-    let xmax = vec![2.0; 4];
+    let xmin = [1.0; 5];
+    let xmax = [2.0; 4];
     let _rectangle = Rectangle::new(Some(&xmin[..]), Some(&xmax[..]));
 }
 
@@ -259,7 +259,7 @@ fn t_rectangle_bounded_negative_entries() {
 
 #[test]
 fn t_rectangle_only_xmin() {
-    let xmin = vec![2.0; 5];
+    let xmin = [2.0; 5];
     let rectangle = Rectangle::new(Some(&xmin[..]), None);
     let mut x = [1.0, 2.0, 3.0, 4.0, 5.0];
 
@@ -276,7 +276,7 @@ fn t_rectangle_only_xmin() {
 
 #[test]
 fn t_rectangle_only_xmax() {
-    let xmax = vec![-3.0; 5];
+    let xmax = [-3.0; 5];
     let rectangle = Rectangle::new(None, Some(&xmax[..]));
     let mut x = [-10.0, -20.0, 0.0, 5.0, 3.0];
 
@@ -1059,7 +1059,7 @@ fn t_ball1_alpha_negative() {
 fn t_epigraph_squared_norm_inside() {
     let epi = EpigraphSquaredNorm::new();
     let mut x = [1., 2., 10.];
-    let x_correct = x.clone();
+    let x_correct = x;
     epi.project(&mut x);
     unit_test_utils::assert_nearly_equal_array(
         &x_correct,
@@ -1088,7 +1088,7 @@ fn t_epigraph_squared_norm_correctness() {
     let mut x = [1., 2., 3., 4.];
     let x_correct = [
         0.560142228903570,
-        1.120284457807140,
+        1.120_284_457_807_14,
         1.680426686710711,
         4.392630432414829,
     ];
@@ -1123,7 +1123,7 @@ fn t_affine_space() {
     let x_correct = [
         1.888564346697095,
         5.629857182200888,
-        1.796204902230790,
+        1.796_204_902_230_79,
         2.888362906715977,
     ];
     unit_test_utils::assert_nearly_equal_array(
@@ -1334,7 +1334,7 @@ fn is_norm_p_projection(
 fn t_ballp_at_origin_projection() {
     let radius = 0.8;
     let mut x = [1.0, -1.0, 6.0];
-    let x0 = x.clone();
+    let x0 = x;
     let p = 3.;
     let tol = 1e-16;
     let max_iters: usize = 200;
@@ -1347,7 +1347,7 @@ fn t_ballp_at_origin_projection() {
 fn t_ballp_at_origin_x_already_inside() {
     let radius = 1.5;
     let mut x = [0.5, -0.2, 0.1];
-    let x0 = x.clone();
+    let x0 = x;
     let p = 3.;
     let tol = 1e-16;
     let max_iters: usize = 1200;