more thorough testing (f32+f64)

Author: alphaville

.github/pull_request_template.md

@@ -13,6 +13,10 @@
 - OpEn version ...
 - opengen version ...
 
+## Merge dependencies
+
+- PR xyz should be merged first
+
 ## Checklist
 
 - [ ] Documentation 

src/alm/tests.rs

@@ -390,6 +390,80 @@ fn t_alm_numeric_test_1() {
     );
 }
 
+#[test]
+fn t_alm_numeric_test_1_f32() {
+    let tolerance = 1e-4_f32;
+    let nx = 3;
+    let n1 = 2;
+    let n2 = 0;
+    let lbfgs_mem = 3;
+    let panoc_cache = PANOCCache::<f32>::new(nx, tolerance, lbfgs_mem);
+    let mut alm_cache = AlmCache::<f32>::new(panoc_cache, n1, n2);
+
+    let set_c = Ball2::new(None, 1.0_f32);
+    let bounds = Ball2::new(None, 10.0_f32);
+    let set_y = Ball2::new(None, 10_000.0_f32);
+
+    let factory = AlmFactory::new(
+        mocks::f0::<f32>,
+        mocks::d_f0::<f32>,
+        Some(mocks::mapping_f1_affine::<f32>),
+        Some(mocks::mapping_f1_affine_jacobian_product::<f32>),
+        no_mapping::<f32>(),
+        no_jacobian_mapping::<f32>(),
+        Some(set_c),
+        n2,
+    );
+
+    let set_c_b = Ball2::new(None, 1.0_f32);
+    let alm_problem = AlmProblem::new(
+        bounds,
+        Some(set_c_b),
+        Some(set_y),
+        |u: &[f32], xi: &[f32], cost: &mut f32| -> FunctionCallResult { factory.psi(u, xi, cost) },
+        |u: &[f32], xi: &[f32], grad: &mut [f32]| -> FunctionCallResult {
+            factory.d_psi(u, xi, grad)
+        },
+        Some(mocks::mapping_f1_affine::<f32>),
+        no_mapping::<f32>(),
+        n1,
+        n2,
+    );
+
+    let mut alm_optimizer = AlmOptimizer::new(&mut alm_cache, alm_problem)
+        .with_delta_tolerance(1e-3_f32)
+        .with_max_outer_iterations(30)
+        .with_epsilon_tolerance(1e-4_f32)
+        .with_initial_inner_tolerance(1e-2_f32)
+        .with_inner_tolerance_update_factor(0.5_f32)
+        .with_initial_penalty(1.0_f32)
+        .with_penalty_update_factor(1.2_f32)
+        .with_sufficient_decrease_coefficient(0.1_f32)
+        .with_initial_lagrange_multipliers(&vec![5.0_f32; n1]);
+
+    let mut u = vec![0.0_f32; nx];
+    let solver_result = alm_optimizer.solve(&mut u);
+    assert!(solver_result.is_ok());
+    let r = solver_result.unwrap();
+    assert_eq!(ExitStatus::Converged, r.exit_status());
+    assert!(r.num_outer_iterations() > 0 && r.num_outer_iterations() <= 30);
+    assert!(r.last_problem_norm_fpr() < tolerance);
+    assert!(r.delta_y_norm_over_c() < 1e-3_f32);
+
+    let mut f1u = vec![0.0_f32; n1];
+    assert!(mocks::mapping_f1_affine(&u, &mut f1u).is_ok());
+    let mut projection = f1u.clone();
+    let set_c_check = Ball2::new(None, 1.0_f32);
+    set_c_check.project(&mut projection);
+    assert!((f1u[0] - projection[0]).abs() < 2e-3_f32);
+    assert!((f1u[1] - projection[1]).abs() < 2e-3_f32);
+
+    let cost_actual = r.cost();
+    let mut cost_expected = 0.0_f32;
+    assert!(mocks::f0(&u, &mut cost_expected).is_ok());
+    assert!((cost_actual - cost_expected).abs() < 2e-3_f32);
+}
+
 fn mapping_f2(u: &[f64], res: &mut [f64]) -> FunctionCallResult {
     res[0] = u[0];
     res[1] = u[1];

src/constraints/tests.rs

@@ -491,6 +491,27 @@ fn t_cartesian_product_ball_and_rectangle() {
     );
 }
 
+#[test]
+fn t_cartesian_product_ball_and_rectangle_f32() {
+    let xmin1 = vec![-1.0_f32; 2];
+    let xmax1 = vec![1.0_f32; 2];
+    let rectangle1 = Rectangle::new(Some(&xmin1), Some(&xmax1));
+
+    let radius = 1.0_f32;
+    let ball = Ball2::new(None, radius);
+
+    let cart_prod = CartesianProduct::new()
+        .add_constraint(2, rectangle1)
+        .add_constraint(5, ball);
+
+    let mut x = [-4.0_f32, 0.25_f32, 2.0_f32, -1.0_f32, 2.0_f32];
+    cart_prod.project(&mut x);
+
+    assert_eq!([-1.0_f32, 0.25_f32], x[..2]);
+    let ball_norm = crate::matrix_operations::norm2(&x[2..5]);
+    assert!((ball_norm - radius).abs() < 1e-5_f32);
+}
+
 #[test]
 fn t_second_order_cone_case_i() {
     let soc = SecondOrderCone::new(1.0);
@@ -529,6 +550,17 @@ fn t_second_order_cone_case_iii() {
     assert!((norm_z - alpha * x[2]).abs() <= 1e-7);
 }
 
+#[test]
+fn t_second_order_cone_case_iii_f32() {
+    let alpha = 1.5_f32;
+    let soc = SecondOrderCone::new(alpha);
+    let mut x = vec![1.0_f32, 1.0_f32, 0.1_f32];
+    soc.project(&mut x);
+    let norm_z = crate::matrix_operations::norm2(&x[..=1]);
+    assert!(norm_z <= alpha * x[2] + 1e-5_f32);
+    assert!((norm_z - alpha * x[2]).abs() <= 1e-4_f32);
+}
+
 #[test]
 #[should_panic]
 fn t_second_order_cone_illegal_alpha_i() {
@@ -885,6 +917,17 @@ fn t_ball1_random_optimality_conditions() {
     }
 }
 
+#[test]
+fn t_ball1_projection_f32() {
+    let ball1 = Ball1::new(None, 1.0_f32);
+    let mut x = [2.0_f32, -1.0_f32, 0.0_f32];
+    ball1.project(&mut x);
+    assert!((x[0] - 1.0_f32).abs() < 1e-6_f32);
+    assert!(x[1].abs() < 1e-6_f32);
+    assert!(x[2].abs() < 1e-6_f32);
+    assert!(crate::matrix_operations::norm1(&x) <= 1.0_f32 + 1e-6_f32);
+}
+
 #[test]
 fn t_ball1_random_optimality_conditions_centered() {
     for n in (10..=60).step_by(10) {

src/core/panoc/panoc_optimizer.rs

@@ -263,6 +263,44 @@ mod tests {
         );
     }
 
+    #[test]
+    fn t_panoc_optimizer_rosenbrock_f32() {
+        let tolerance = 1e-4_f32;
+        let a_param = 1.0_f32;
+        let b_param = 200.0_f32;
+        let n_dimension = 2;
+        let lbfgs_memory = 8;
+        let max_iters = 120;
+        let mut u_solution = [-1.5_f32, 0.9_f32];
+
+        let cost_gradient = |u: &[f32], grad: &mut [f32]| -> FunctionCallResult {
+            mocks::rosenbrock_grad(a_param, b_param, u, grad);
+            Ok(())
+        };
+        let cost_function = |u: &[f32], c: &mut f32| -> FunctionCallResult {
+            *c = mocks::rosenbrock_cost(a_param, b_param, u);
+            Ok(())
+        };
+
+        let radius = 2.0_f32;
+        let bounds = constraints::Ball2::new(None, radius);
+        let mut panoc_cache = PANOCCache::<f32>::new(n_dimension, tolerance, lbfgs_memory);
+        let problem = Problem::new(&bounds, cost_gradient, cost_function);
+        let mut panoc = PANOCOptimizer::new(problem, &mut panoc_cache).with_max_iter(max_iters);
+        let status = panoc.solve(&mut u_solution).unwrap();
+
+        assert_eq!(max_iters, panoc.max_iter);
+        assert!(status.has_converged());
+        assert!(status.iterations() < max_iters);
+        assert!(status.norm_fpr() < tolerance);
+
+        let mut u_project = [0.0_f32; 2];
+        u_project.copy_from_slice(&u_solution);
+        bounds.project(&mut u_project);
+        assert!((u_solution[0] - u_project[0]).abs() < 1e-5_f32);
+        assert!((u_solution[1] - u_project[1]).abs() < 1e-5_f32);
+    }
+
     #[test]
     fn t_panoc_in_loop() {
         /* USER PARAMETERS */