INLPProblem.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include <vector>
 
 
AST_NAMESPACE_BEGIN
 
 
 
struct NLPInfo
{
    int  numVariable_{ 0 };           // 优化变量的维度，默认为0
    int  numConstraintEq_{ 0 };       // 等式约束的维度，默认为0
    int  numConstraintIneq_{ 0 };     // 不等式约束维度，默认为0
    int  numObjective_{ 0 };          // 优化目标的维度，默认为0
 
public:
    int getNumConstraint() const
    {
        return getNumConstraintEq() + getNumConstraintIneq();
    }
    int getNumObjConstr() const
    {
        return getNumObjective() + getNumConstraint();
    }
    int getNumVariable() const
    {
        return numVariable_;
    }
    int getNumObjective() const
    {
        return numObjective_;
    }
    int getNumConstraintEq() const
    {
        return numConstraintEq_;
    }
    int getNumConstraintIneq() const
    {
        return numConstraintIneq_;
    }
 
    int& numVariable(){return numVariable_;}
    int& numConstraintEq(){return numConstraintEq_;}
    int& numConstraintIneq(){return numConstraintIneq_;}
    int& numObjective(){return numObjective_;}
};
 
 
// @brief 非线性规划问题的雅可比矩阵信息 
struct NLPJacInfo
{
    std::vector<int> idxVariable_;       // 变量索引，从0开始
    std::vector<int> idxConstraint_;     // 约束索引，从0开始
};
 
struct NLPVectorBounds
{
    size_t  size_{ 0 };              // 维度
    double* lower_{ nullptr };       // 下界
    double* upper_{ nullptr };       // 上界
public:
    size_t size() const { return size_; }
    size_t& size(){return size_;}
    double* lower(){return lower_;}
    double* upper(){return upper_;}
};
 
struct NLPVector
{
    double* data_{ nullptr };         // 数值
    size_t  size_{ 0 };                // 维度
public:
    double* data() const {return data_;}
    size_t& size(){return size_;}
    size_t size() const { return size_; }
    double& operator[](size_t index) {return data_[index];}
    double operator[](size_t index) const {return data_[index];}
};
 
struct NLPBounds
{
    NLPVectorBounds variable_;        // 优化变量的上下界，不设置则默认是  -∞ <= variable <= +∞
    NLPVectorBounds constraintIneq_;  // 不等式约束上下界，不设置则默认是  -∞ <= constrIneq <= 0
    NLPVector       constraintEq_;    // 等式约束的期望值，不设置则默认是 0
public:
    NLPVectorBounds& variable(){return variable_;}
    NLPVectorBounds& constraintIneq(){return constraintIneq_;}
    NLPVector& constraintEq(){return constraintEq_;}
};
 
struct NLPInput
{
    NLPVector variable_;
public:
    NLPVector& variable(){return variable_;}
    const NLPVector& variable() const {return variable_;}
};
 
struct NLPOutput
{
    NLPVector objective_;
    NLPVector constraintEq_;
    NLPVector constraintIneq_;
public:
    NLPVector& objective(){return objective_;}
    NLPVector& constraintEq(){return constraintEq_;}
    NLPVector& constraintIneq(){return constraintIneq_;}
};
 
 
class INLPProblem
{
public:
    virtual ~INLPProblem() = default;
 
    virtual errc_t getInfo(NLPInfo& info) const = 0;
 
    virtual errc_t getJacInfo(NLPJacInfo& info) const = 0;
 
    virtual errc_t getBounds(NLPBounds& bounds) const = 0;
 
 
    virtual errc_t evalFitness(const NLPInput& input, NLPOutput& output) const = 0;
 
 
    virtual errc_t evalJacobi(int numVariable, const double* variable, int numConstraint, int nnzJacobi, double* nzElemjacobi) const = 0;
 
 
    virtual errc_t evalGradient(int numVariable, const double* variable, double* grad) const = 0;
 
 
    virtual errc_t getInitialGuess(int numVariable, double* variable) const = 0;
 
 
};
 
 
AST_NAMESPACE_END