cargo fmt

Author: alphaville

src/alm/alm_optimizer.rs

@@ -2,7 +2,9 @@ use crate::{
     alm::*,
     constraints,
     core::{panoc::PANOCOptimizer, ExitStatus, Problem, SolverStatus},
-    matrix_operations, numeric::cast, FunctionCallResult, SolverError,
+    matrix_operations,
+    numeric::cast,
+    FunctionCallResult, SolverError,
 };
 use lbfgs::LbfgsPrecision;
 use num::Float;

src/constraints/affine_space.rs

@@ -84,14 +84,12 @@ where
         let aat = matrix_operations::mul_a_at(&a, n_rows, n_cols)
             .map_err(|_| AffineSpaceError::IncompatibleDimensions)?;
         let mut factorizer = CholeskyFactorizer::new(n_rows);
-        factorizer
-            .factorize(&aat)
-            .map_err(|err| match err {
-                CholeskyError::NotPositiveDefinite => AffineSpaceError::NotFullRowRank,
-                CholeskyError::DimensionMismatch | CholeskyError::NotFactorized => {
-                    AffineSpaceError::IncompatibleDimensions
-                }
-            })?;
+        factorizer.factorize(&aat).map_err(|err| match err {
+            CholeskyError::NotPositiveDefinite => AffineSpaceError::NotFullRowRank,
+            CholeskyError::DimensionMismatch | CholeskyError::NotFactorized => {
+                AffineSpaceError::IncompatibleDimensions
+            }
+        })?;
         Ok(AffineSpace {
             a_mat: a,
             b_vec: b,

src/constraints/ballp.rs

@@ -249,11 +249,7 @@ impl<'a, T: Float> BallP<'a, T> {
                 lo = u;
             }
 
-            let df = T::one()
-                + lambda
-                    * p
-                    * (p - T::one())
-                    * u.powf(p - cast::<T>(2.0));
+            let df = T::one() + lambda * p * (p - T::one()) * u.powf(p - cast::<T>(2.0));
             let mut candidate = u - f / df;
 
             if !candidate.is_finite() || candidate <= lo || candidate >= hi {

src/constraints/tests.rs

@@ -1295,10 +1295,7 @@ fn t_affine_space_try_new_rank_deficient() {
     let a = vec![1.0, 2.0, 2.0, 4.0];
     let b = vec![1.0, 2.0];
     let affine_set = AffineSpace::try_new(a, b);
-    assert!(matches!(
-        affine_set,
-        Err(AffineSpaceError::NotFullRowRank)
-    ));
+    assert!(matches!(affine_set, Err(AffineSpaceError::NotFullRowRank)));
 }
 
 #[test]
@@ -1654,9 +1651,7 @@ where
                 .collect();
 
             for _ in 0..150 {
-                let z_feasible: Vec<f64> = (0..dim)
-                    .map(|_| rng.random_range(-3.0..3.0))
-                    .collect();
+                let z_feasible: Vec<f64> = (0..dim).map(|_| rng.random_range(-3.0..3.0)).collect();
                 let norm_z_sq_feasible = z_feasible.iter().map(|zi| zi * zi).sum::<f64>();
                 let t_feasible = norm_z_sq_feasible + rng.random_range(0.0..3.0);
                 let mut y = z_feasible;

src/core/panoc/panoc_engine.rs

@@ -1,7 +1,9 @@
 use crate::{
     constraints,
     core::{panoc::PANOCCache, AlgorithmEngine, Problem},
-    matrix_operations, numeric::cast, FunctionCallResult, SolverError,
+    matrix_operations,
+    numeric::cast,
+    FunctionCallResult, SolverError,
 };
 use lbfgs::LbfgsPrecision;
 use num::Float;
@@ -210,8 +212,7 @@ where
             self.cache.lbfgs.reset(); // invalidate the L-BFGS buffer
 
             // update L, sigma and gamma...
-            self.cache.lipschitz_constant =
-                self.cache.lipschitz_constant * cast::<T>(2.0);
+            self.cache.lipschitz_constant = self.cache.lipschitz_constant * cast::<T>(2.0);
             self.cache.gamma = self.cache.gamma / cast::<T>(2.0);
 
             // recompute the half step...
@@ -226,8 +227,7 @@ where
             self.compute_fpr(u_current);
             it_lipschitz_search += 1;
         }
-        self.cache.sigma = (T::one() - gamma_l_coeff::<T>())
-            / (cast::<T>(4.0) * self.cache.gamma);
+        self.cache.sigma = (T::one() - gamma_l_coeff::<T>()) / (cast::<T>(4.0) * self.cache.gamma);
 
         Ok(())
     }
@@ -390,8 +390,7 @@ where
         self.cache_gradient_norm();
         self.cache.gamma =
             gamma_l_coeff::<T>() / self.cache.lipschitz_constant.max(min_l_estimate());
-        self.cache.sigma = (T::one() - gamma_l_coeff::<T>())
-            / (cast::<T>(4.0) * self.cache.gamma);
+        self.cache.sigma = (T::one() - gamma_l_coeff::<T>()) / (cast::<T>(4.0) * self.cache.gamma);
         self.gradient_step(u_current); // updated self.cache.gradient_step
         self.half_step(); // updates self.cache.u_half_step