decl/alm.hpp

Go to the documentation of this file.

#pragma once
 
#include <panoc-alm/inner/decl/panoc-fwd.hpp>
#include <panoc-alm/util/problem.hpp>
#include <panoc-alm/util/solverstatus.hpp>
 
#include <chrono>
#include <string>
 
namespace pa {
 
struct ALMParams {
    real_t ε = 1e-5;
    real_t δ = 1e-5;
    real_t Δ = 10;
    real_t Δ_lower = 0.8;
    real_t Σ₀ = 1;
    real_t σ₀ = 20;
    real_t Σ₀_lower = 0.6;
    real_t ε₀ = 1;
    real_t ε₀_increase = 1.1;
    real_t ρ = 1e-1;
    real_t ρ_increase = 2;
    real_t θ = 0.1;
    real_t M = 1e9;
    real_t Σ_max = 1e9;
    real_t Σ_min = 1e-9;
    unsigned int max_iter = 100;
    std::chrono::microseconds max_time = std::chrono::minutes(5);
 
    unsigned max_num_initial_retries = 20;
    unsigned max_num_retries = 20;
    unsigned max_total_num_retries = 40;
 
    unsigned print_interval = 0;
 
    bool preconditioning = false;
    bool single_penalty_factor = false;
};
 
template <class InnerSolverT = PANOCSolver<>>
class ALMSolver {
  public:
    using Params      = ALMParams;
    using InnerSolver = InnerSolverT;
 
    struct Stats {
        unsigned outer_iterations = 0;
        std::chrono::microseconds elapsed_time;
        unsigned initial_penalty_reduced    = 0;
        unsigned penalty_reduced            = 0;
        unsigned inner_convergence_failures = 0;
        real_t ε                            = inf;
        real_t δ                            = inf;
        real_t norm_penalty                 = 0;
 
        SolverStatus status = SolverStatus::Unknown;
 
        InnerStatsAccumulator<typename InnerSolver::Stats> inner;
    };
 
    ALMSolver(Params params, InnerSolver &&inner_solver)
        : params(params),
          inner_solver(std::forward<InnerSolver>(inner_solver)) {}
    ALMSolver(Params params, const InnerSolver &inner_solver)
        : params(params), inner_solver(inner_solver) {}
 
    Stats operator()(const Problem &problem, rvec y, rvec x);
 
    std::string get_name() const {
        return "ALMSolver<" + inner_solver.get_name() + ">";
    }
 
    void stop() { inner_solver.stop(); }
 
    const Params &get_params() const { return params; }
 
  private:
    Params params;
 
  public:
    InnerSolver inner_solver;
};
 
} // namespace pa