include/panoc-alm/util/problem.hpp

Go to the documentation of this file.

#pragma once
 
#include "box.hpp"
 
#include <functional>
#include <memory>
#include <type_traits>
 
namespace pa {
 
struct Problem {
    unsigned int n; 
    unsigned int m; 
    Box C;          
    Box D;          
 
    using f_sig = real_t(crvec x);
    using grad_f_sig = void(crvec x, rvec grad_fx);
    using g_sig = void(crvec x, rvec gx);
    using grad_g_prod_sig = void(crvec x, crvec y, rvec grad_gxy);
    using grad_gi_sig = void(crvec x, unsigned i, rvec grad_gi);
    using hess_L_prod_sig = void(crvec x, crvec y, crvec v, rvec Hv);
    using hess_L_sig = void(crvec x, crvec y, rmat H);
 
    std::function<f_sig> f;
    std::function<grad_f_sig> grad_f;
    std::function<g_sig> g;
    std::function<grad_g_prod_sig> grad_g_prod;
    std::function<grad_gi_sig> grad_gi;
    std::function<hess_L_prod_sig> hess_L_prod;
    std::function<hess_L_sig> hess_L;
 
    Problem() = default;
    Problem(unsigned int n, unsigned int m)
        : n(n), m(m), C{vec::Constant(n, +inf), vec::Constant(n, -inf)},
          D{vec::Constant(m, +inf), vec::Constant(m, -inf)} {}
    Problem(unsigned n, unsigned int m, Box C, Box D, std::function<f_sig> f,
            std::function<grad_f_sig> grad_f, std::function<g_sig> g,
            std::function<grad_g_prod_sig> grad_g_prod,
            std::function<grad_gi_sig> grad_gi,
            std::function<hess_L_prod_sig> hess_L_prod,
            std::function<hess_L_sig> hess_L)
        : n(n), m(m), C(std::move(C)), D(std::move(D)), f(std::move(f)),
          grad_f(std::move(grad_f)), g(std::move(g)),
          grad_g_prod(std::move(grad_g_prod)), grad_gi(std::move(grad_gi)),
          hess_L_prod(std::move(hess_L_prod)), hess_L(std::move(hess_L)) {}
};
 
class ProblemWithParam : public pa::Problem {
  public:
    using pa::Problem::Problem;
    void set_param(pa::crvec p) { *param = p; }
    void set_param(pa::vec &&p) { *param = std::move(p); }
    pa::vec &get_param() { return *param; }
    const pa::vec &get_param() const { return *param; }
    std::shared_ptr<pa::vec> get_param_ptr() const { return param; }
 
  private:
    std::shared_ptr<pa::vec> param = std::make_shared<pa::vec>();
};
 
struct EvalCounter {
    unsigned f           = 0;
    unsigned grad_f      = 0;
    unsigned g           = 0;
    unsigned grad_g_prod = 0;
    unsigned grad_gi     = 0;
    unsigned hess_L_prod = 0;
    unsigned hess_L      = 0;
 
    void reset() { *this = {}; }
};
 
inline EvalCounter &operator+=(EvalCounter &a, EvalCounter b) {
    a.f += b.f;
    a.grad_f += b.grad_f;
    a.g += b.g;
    a.grad_g_prod += b.grad_g_prod;
    a.grad_gi += b.grad_gi;
    a.hess_L_prod += b.hess_L_prod;
    a.hess_L += b.hess_L;
    return a;
}
 
inline EvalCounter operator+(EvalCounter a, EvalCounter b) { return a += b; }
 
class ProblemWithCounters : public Problem {
  public:
    ProblemWithCounters(Problem &&p) : Problem(std::move(p)) {
        attach_counters(*this);
    }
    ProblemWithCounters(const Problem &p) : Problem(p) {
        attach_counters(*this);
    }
 
    ProblemWithCounters()                            = delete;
    ProblemWithCounters(const ProblemWithCounters &) = delete;
    ProblemWithCounters(ProblemWithCounters &&)      = delete;
    ProblemWithCounters &operator=(const ProblemWithCounters &) = delete;
    ProblemWithCounters &operator=(ProblemWithCounters &&) = delete;
 
  public:
    EvalCounter evaluations;
 
  private:
    static void attach_counters(ProblemWithCounters &);
};
 
class ProblemOnlyD : public Problem {
  public:
    ProblemOnlyD(Problem &&p) : original(std::move(p)) { transform(); }
    ProblemOnlyD(const Problem &p) : original(p) { transform(); }
 
  private:
    Problem original; // TODO: Keeping this copy around is unnecessary.
    vec work;
 
    void transform();
};
 
struct ProblemFull {
    unsigned int n; 
    unsigned int m1; 
    unsigned int m2; 
    Box C;          
    Box D1;          
    Box D2;          
 
    using f_sig = real_t(crvec x);
    using grad_f_sig = void(crvec x, rvec grad_fx);
    using g1_sig = void(crvec x, rvec g1x);
    using grad_g1_prod_sig = void(crvec x, crvec y, rvec grad_g1xy);
    using grad_g1i_sig = void(crvec x, unsigned i, rvec grad_g1i);
    using g2_sig = void(crvec x, rvec g2x);
    using grad_g2_prod_sig = void(crvec x, crvec y, rvec grad_g2xy);
    using grad_g2i_sig = void(crvec x, unsigned i, rvec grad_g2i);
    using hess_L_prod_sig = void(crvec x, crvec y, crvec v, rvec Hv);
    using hess_L_sig = void(crvec x, crvec y, rmat H);
 
    std::function<f_sig> f;
    std::function<grad_f_sig> grad_f;
    std::function<g1_sig> g1;
    std::function<grad_g1_prod_sig> grad_g1_prod;
    std::function<grad_g1i_sig> grad_g1i;
    std::function<g2_sig> g2;
    std::function<grad_g2_prod_sig> grad_g2_prod;
    std::function<grad_g2i_sig> grad_g2i;
    std::function<hess_L_prod_sig> hess_L_prod;
    std::function<hess_L_sig> hess_L;
 
    ProblemFull() = default;
    ProblemFull(unsigned int n, unsigned int m1, unsigned int m2)
        : n(n), m1(m1), m2(m2), C{vec::Constant(n, +inf), vec::Constant(n, -inf)},
          D1{vec::Constant(m1, +inf), vec::Constant(m1, -inf)},
          D2{vec::Constant(m1, +inf), vec::Constant(m1, -inf)} {}
    ProblemFull(unsigned n, unsigned int m1, unsigned int m2, Box C, Box D1, Box D2,
            std::function<f_sig> f,
            std::function<grad_f_sig> grad_f,
            std::function<g1_sig> g1,
            std::function<grad_g1_prod_sig> grad_g1_prod,
            std::function<grad_g1i_sig> grad_g1i,
            std::function<g2_sig> g2,
            std::function<grad_g2_prod_sig> grad_g2_prod,
            std::function<grad_g2i_sig> grad_g2i,
            std::function<hess_L_prod_sig> hess_L_prod,
            std::function<hess_L_sig> hess_L)
        : n(n), m1(m1), m2(m2), C(std::move(C)), D1(std::move(D1)), D2(std::move(D2)),
          f(std::move(f)), grad_f(std::move(grad_f)), g1(std::move(g1)),
          grad_g1_prod(std::move(grad_g1_prod)), grad_g1i(std::move(grad_g1i)),
          g2(std::move(g2)), grad_g2_prod(std::move(grad_g2_prod)),
          grad_g2i(std::move(grad_g2i)), hess_L_prod(std::move(hess_L_prod)),
          hess_L(std::move(hess_L)) {}
};
 
class ProblemFullWithParam : public pa::ProblemFull {
  public:
    using pa::ProblemFull::ProblemFull;
    void set_param(pa::crvec p) { *param = p; }
    void set_param(pa::vec &&p) { *param = std::move(p); }
    pa::vec &get_param() { return *param; }
    const pa::vec &get_param() const { return *param; }
    std::shared_ptr<pa::vec> get_param_ptr() const { return param; }
 
  private:
    std::shared_ptr<pa::vec> param = std::make_shared<pa::vec>();
};
 
struct EvalCounterFull {
    unsigned f           = 0;
    unsigned grad_f      = 0;
    unsigned g           = 0;
    unsigned grad_g_prod = 0;
    unsigned grad_gi     = 0;
    unsigned hess_L_prod = 0;
    unsigned hess_L      = 0;
 
    void reset() { *this = {}; }
};
 
inline EvalCounterFull &operator+=(EvalCounterFull &a, EvalCounterFull b) {
    a.f += b.f;
    a.grad_f += b.grad_f;
    a.g += b.g;
    a.grad_g_prod += b.grad_g_prod;
    a.grad_gi += b.grad_gi;
    a.hess_L_prod += b.hess_L_prod;
    a.hess_L += b.hess_L;
    return a;
}
 
inline EvalCounterFull operator+(EvalCounterFull a, EvalCounterFull b) { return a += b; }
 
// class ProblemWithCounters : public Problem {
//   public:
//     ProblemWithCounters(Problem &&p) : Problem(std::move(p)) {
//         attach_counters(*this);
//     }
//     ProblemWithCounters(const Problem &p) : Problem(p) {
//         attach_counters(*this);
//     }
 
//     ProblemWithCounters()                            = delete;
//     ProblemWithCounters(const ProblemWithCounters &) = delete;
//     ProblemWithCounters(ProblemWithCounters &&)      = delete;
//     ProblemWithCounters &operator=(const ProblemWithCounters &) = delete;
//     ProblemWithCounters &operator=(ProblemWithCounters &&) = delete;
 
//   public:
//     EvalCounter evaluations;
 
//   private:
//     static void attach_counters(ProblemWithCounters &);
// };
 
// /// Moves the state constraints in the set C to the set D, resulting in an
// /// unconstraint inner problem. The new constraints function g becomes the
// /// concatenation of the original g function and the identity function. The
// /// new set D is the cartesian product of the original D × C.
// class ProblemOnlyD : public Problem {
//   public:
//     ProblemOnlyD(Problem &&p) : original(std::move(p)) { transform(); }
//     ProblemOnlyD(const Problem &p) : original(p) { transform(); }
 
//   private:
//     Problem original; // TODO: Keeping this copy around is unnecessary.
//     vec work;
 
//     void transform();
// };
 
} // namespace pa