constraint-set.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "proxsuite-nlp/function-base.hpp"
#include "proxsuite-nlp/third-party/polymorphic_cxx14.hpp"
 
namespace proxsuite {
namespace nlp {
 
template <typename _Scalar> struct ConstraintSetTpl {
public:
  using Scalar = _Scalar;
  PROXSUITE_NLP_DYNAMIC_TYPEDEFS(Scalar);
  using ActiveType = Eigen::Matrix<bool, Eigen::Dynamic, 1>;
 
  ConstraintSetTpl() = default;
 
  virtual bool disableGaussNewton() const { return true; }
 
  virtual Scalar evaluate(const ConstVectorRef & /*zproj*/) const { return 0.; }
 
  virtual void projection(const ConstVectorRef &z, VectorRef zout) const = 0;
 
  virtual void normalConeProjection(const ConstVectorRef &z,
                                    VectorRef zout) const = 0;
 
  virtual void applyProjectionJacobian(const ConstVectorRef &z,
                                       MatrixRef Jout) const;
 
  virtual void applyNormalConeProjectionJacobian(const ConstVectorRef &z,
                                                 MatrixRef Jout) const;
 
  void setProxParameter(const Scalar mu) const {
    mu_ = mu;
    mu_inv_ = 1. / mu;
  };
 
  virtual void computeActiveSet(const ConstVectorRef &z,
                                Eigen::Ref<ActiveType> out) const = 0;
 
  virtual ~ConstraintSetTpl<Scalar>() = default;
 
  bool operator==(const ConstraintSetTpl<Scalar> &rhs) { return this == &rhs; }
 
  Scalar evaluateMoreauEnvelope(const ConstVectorRef &zin,
                                const ConstVectorRef &zproj) const {
    Scalar res = evaluate(zin - zproj);
    res += static_cast<Scalar>(0.5) * mu_inv_ * zproj.squaredNorm();
    return res;
  }
 
  Scalar computeMoreauEnvelope(const ConstVectorRef &zin,
                               VectorRef zprojout) const {
    normalConeProjection(zin, zprojout);
    return evaluateMoreauEnvelope(zin, zprojout);
  }
 
  Scalar mu() const { return mu_; }
  Scalar mu_inv() const { return mu_inv_; }
 
protected:
  mutable Scalar mu_ = 0.;
  mutable Scalar mu_inv_;
};
 
template <typename _Scalar> struct ConstraintObjectTpl {
  using Scalar = _Scalar;
  PROXSUITE_NLP_DYNAMIC_TYPEDEFS(Scalar);
 
  using FunctionType = C2FunctionTpl<Scalar>;
  using ConstraintSet = ConstraintSetTpl<Scalar>;
 
  shared_ptr<FunctionType> func_;
  polymorphic<ConstraintSet> set_;
 
  const FunctionType &func() const { return *func_; }
  int nr() const { return func_->nr(); }
 
  // Must be defined because of MSVC explicit template instantiation
  ConstraintObjectTpl(ConstraintObjectTpl &&) = default;
  ConstraintObjectTpl &operator=(ConstraintObjectTpl &&) = default;
  ConstraintObjectTpl(const ConstraintObjectTpl &) = default;
  ConstraintObjectTpl &operator=(const ConstraintObjectTpl &) = default;
 
  ConstraintObjectTpl(shared_ptr<FunctionType> func,
                      const polymorphic<ConstraintSet> &set)
      : func_(func), set_(set) {}
 
  bool operator==(const ConstraintObjectTpl &other) const {
    return func_ == other.func_;
  }
};
 
#ifdef PROXSUITE_NLP_ENABLE_TEMPLATE_INSTANTIATION
extern template struct PROXSUITE_NLP_EXPLICIT_INSTANTIATION_DECLARATION_DLLAPI
    ConstraintSetTpl<context::Scalar>;
extern template struct PROXSUITE_NLP_EXPLICIT_INSTANTIATION_DECLARATION_DLLAPI
    ConstraintObjectTpl<context::Scalar>;
#endif
 
} // namespace nlp
} // namespace proxsuite
 
#include "proxsuite-nlp/constraint-set.hxx"