FeasibleRegionStudy.hpp

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstCore/Command.hpp"
 
AST_NAMESPACE_BEGIN
 
class AST_ANALYZER_API FeasibleRegionVariable: public ObjectNamed
{
public:
    AST_OBJECT(FeasibleRegionVariable)
public:
    FeasibleRegionVariable() = default;
    ~FeasibleRegionVariable() = default;
 
    double lower() const { return lower_; }
    void setLower(double lower) { lower_ = lower; }
 
    double upper() const { return upper_; }
    void setUpper(double upper) { upper_ = upper; }
 
    int steps() const { return steps_; }
    void setSteps(int steps) { steps_ = steps; }
 
    Expr* expr() const { return expr_.get(); }
    void setExpr(Expr* expr) { expr_ = expr; }
 
    void generateValueList();
 
    const std::vector<double>& values() const { return values_; }
    std::vector<double>& values() { return values_; }
 
    errc_t getValue(double& value) const;
    errc_t setValue(double value);
 
private:
    SharedPtr<Expr> expr_;          
    double lower_{};                
    double upper_{};                
    int steps_{10};                 
    std::vector<double> values_;    
};
 
 
class AST_ANALYZER_API FeasibleRegionConstraint: public ObjectNamed
{
public:
    AST_OBJECT(FeasibleRegionConstraint)
 
public:
    FeasibleRegionConstraint() = default;
    ~FeasibleRegionConstraint() = default;
 
    bool useLower() const { return useLower_; }
    void setUseLower(bool useLower) { useLower_ = useLower; }
 
    bool useUpper() const { return useUpper_; }
    void setUseUpper(bool useUpper) { useUpper_ = useUpper; }
 
    bool exclude() const { return exclude_; }
    void setExclude(bool exclude) { exclude_ = exclude; }
    
    double lower() const { return lower_; }
    void setLower(double lower) { lower_ = lower; }
    
    double upper() const { return upper_; }
    void setUpper(double upper) { upper_ = upper; }
 
    Expr* expr() const { return expr_.get(); }
    void setExpr(Expr* expr) { expr_ = expr; }
 
    errc_t getValue(double& value) const;
 
private:
    bool useLower_{};               
    bool useUpper_{};               
    bool exclude_{};                
    double lower_{};                
    double upper_{};                
    SharedPtr<Expr> expr_;          
};
 
 
class AST_ANALYZER_API FeasibleRegionStudy: public Command
{
public:
    AST_OBJECT(FeasibleRegionStudy)
    using VariableType = FeasibleRegionVariable;
    using ConstraintType = FeasibleRegionConstraint;
    using VariableList = std::vector<SharedPtr<VariableType>>;
    using ConstraintList = std::vector<SharedPtr<ConstraintType>>;
public:
    FeasibleRegionStudy() = default;
    ~FeasibleRegionStudy() override = default;
 
    errc_t execute() override;
 
    VariableList& variables() { return variables_; }
    const VariableList& variables() const { return variables_; }
 
    ConstraintList& constraints() { return constraints_; }
    const ConstraintList& constraints() const { return constraints_; }
 
    Command* relatedCommand() const { return relatedCommand_.get(); }
 
    void setRelatedCommand(Command* command) { relatedCommand_ = command; }
 
    void addVariable(VariableType* variable);
 
    void removeVariable(VariableType* variable);
 
    void addConstraint(ConstraintType* constraint);
 
    void removeConstraint(ConstraintType* constraint);
 
    int totalRuns() const;
 
    void stepIndexToVarIndices(int stepIndex, std::vector<int>& indices) const;
 
    errc_t executeStep(int stepIndex, bool& isFeasible);
 
private:
    VariableList variables_;                            
    ConstraintList constraints_;                        
    mutable WeakPtr<Command> relatedCommand_;           
};
 
AST_NAMESPACE_END