FMTconstraint.hpp

Go to the documentation of this file.

/*
Copyright (c) 2019 Gouvernement du Québec
 
SPDX-License-Identifier: LiLiQ-R-1.1
License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt
*/
 
#ifndef FMTconstraint_H_INCLUDED
#define FMTconstraint_H_INCLUDED
 
#include "FMToutput.hpp"
#include <vector>
#include <string>
#include <limits>
#include "FMTbounds.hpp"
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/export.hpp>
 
namespace Core
{
class FMTtransition;
class FMTtheme;
class FMTaction;
class FMTyields;
// DocString: FMTconstrainttype
enum  FMTconstrainttype
{
    FMTMAXobjective = 1,
    FMTMINobjective = 2,
    FMTMAXMINobjective = 3,
    FMTMINMAXobjective = 4,
    FMTevenflow = 5,
    FMTnondeclining = 6,
    FMTsequence = 7,
    FMTstandard = 8,
    FMTspatialsize = 9,
    FMTspatialadjacency = 10,
    FMTspatialgreenup = 11,
    FMTrandomaction = 12//need to be deleted
};
// DocString: FMTconstraint
class FMTEXPORT FMTconstraint: public FMToutput,public FMTspec
    {
    // DocString: FMTconstraint::serialize
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar & boost::serialization::make_nvp("output", boost::serialization::base_object<FMToutput>(*this));
        ar & boost::serialization::make_nvp("specification", boost::serialization::base_object<FMTspec>(*this));
        ar & BOOST_SERIALIZATION_NVP(type);
    }
    // DocString: FMTconstraint::type
    FMTconstrainttype type;
    // DocString: FMTconstraint::standardstring
    void standardstring(std::string& line, std::string& period_bounds, std::string& goal, std::string& global) const;
    // DocString: FMTconstraint::getmaxandmin
    void getmaxandmin(const std::vector<double>& values, double& min,double& max) const;
    // DocString: FMTconstraint::getsum
    double getsum(const std::vector<double>& values) const;
    // DocString: FMTconstraint::getperiodicvariationcost
    double getperiodicvariationcost(const std::vector<double>& values, bool evaluateupper=false) const;
    // DocString: FMTconstraint::getvariability
    double getvariability(const std::vector<double>& values,const double& var,const double& lowarvar) const;
 
    public:
        // DocString: FMTconstraint()
        FMTconstraint();
        // DocString: FMTconstraint(FMTconstrainttype,const FMToutput&)
        FMTconstraint(FMTconstrainttype ltype, const FMToutput& loutput);
        // DocString: FMTconstraint(const FMTconstraint&)
        FMTconstraint(const FMTconstraint& rhs);
        // DocString: FMTconstraint::operator=
        FMTconstraint& operator = (const FMTconstraint& rhs);
        // DocString: FMTconstraint::operator==
        bool operator == (const FMTconstraint& rhs) const;
        // DocString: FMTconstraint::operator!=
        bool operator != (const FMTconstraint& rhs) const;
        // DocString: FMTconstraint::extravariables
        bool extravariables() const;
        // DocString: FMTconstraint::isgoal
        bool isgoal() const;
        // DocString: FMTconstraint::issetfrom
        bool issetfrom(const std::string& modeltype) const;
        // DocString: FMTconstraint::isreignore
        bool isreignore(const int& replanningperiod) const;
        // DocString: FMTconstraint::dosupportrandom
        bool dosupportrandom() const;
        // DocString: FMTconstraint::setfrom
        Core::FMTconstraint setfrom(const std::string& modeltype,const double& value) const;
        // DocString: FMTconstraint::getscheduleweight
        double getscheduleweight() const;
        // DocString: FMTconstraint::getiterationchange
        Core::FMTconstraint getiterationchange(const std::vector<double>& periodchanges,const int& targetperiod) const;
        // DocString: FMTconstraint::getfromreplicate
        Core::FMTconstraint getfromreplicate(const size_t& replicate,const int& period) const;
        // DocString: FMTconstraint::getpenalties
        std::vector<std::string>getpenalties(double & sense) const;
        // DocString: FMTconstraint::getvariablelevels
        std::vector<std::string>getvariablelevels() const;
        // DocString: FMTconstraint::getgoal
        void getgoal(std::string& name,double& value) const;
        // DocString: FMTconstraint::setgoal
        void setgoal(const std::string& goalname, const double& value);
        // DocString: FMTconstraint::setpenalties
        void setpenalties(const std::string& penaltyoperator, const std::vector<std::string>& variables);
        // DocString: FMTconstraint::isobjective
        bool isobjective() const;
        // DocString: FMTconstraint::sense
        double sense() const;
        // DocString: FMTconstraint::getbounds
        void getbounds(double& lower, double& upper,int period = 0) const;
        // DocString: FMTconstraint::setrhs
        void setrhs(double lower,double upper);
        // DocString: FMTconstraint::setlength
        void setlength(int firstperiod = 1,int lastperiod = std::numeric_limits<int>::max());
        // DocString: FMTconstraint::getvariations
        void getvariations(double& lower, double& upper) const;
        // DocString: FMTconstraint::ismultiple
        bool ismultiple() const;
        // DocString: FMTconstraint::acrossperiod
        bool acrossperiod() const;
        // DocString: FMTconstraint::hash
        size_t hash(bool hashrhs = true,bool hashoutputonly = false) const;
        // DocString: FMTconstraint::hashasoutput
        size_t hashasoutput() const;
        // DocString: FMTconstraint::setoutput
        void setoutput(const FMToutput& out);
        // DocString: FMTconstraint::setconstrainttype
        void setconstrainttype(FMTconstrainttype ltype);
        // DocString: FMTconstraint::getconstrainttype
        FMTconstrainttype getconstrainttype() const;
        // DocString: FMTconstraint::operator std::string
        operator std::string() const;
        // DocString: FMTconstraint::isspatial
        bool isspatial() const;
        // DocString: FMTconstraint::israndomaction
        bool israndomaction() const;
        // DocString: FMTconstraint::getgroup
        size_t getgroup() const;
        // DocString: FMTconstraint::outputempty
        size_t outputempty() const;
        // DocString: FMTconstraint::presolve
        FMTconstraint presolve(const FMTmaskfilter& filter,
            const std::vector<FMTtheme>& originalthemes,
            const std::vector<FMTtheme>& selectedthemes,
            const std::vector<FMTtheme>& newthemes,
            const std::vector<FMTaction>& actions, const FMTyields& yields) const;
        // DocString: ~FMTconstraint()
        ~FMTconstraint()=default;
        // DocString: FMTconstraint::evaluate
        double evaluate(const std::vector<double>& temporalvalues) const;
        // DocString: FMTconstraint::getactionids
        std::vector<int>getactionids(const std::vector<Core::FMTaction>& actions) const;
        // DocString: FMTconstraint::isactionsused
        std::vector<bool>isactionsused(const std::vector<Core::FMTaction>& actions) const;
        // DocString: FMTconstraint::canbeturnedtoyieldsbasedontransitions
        bool canbeturnedtoyieldsbasedontransitions() const;
        // DocString: FMTconstraint::turntoyieldsbasedontransition
        void turntoyieldsbasedontransition( const std::vector<Core::FMTtheme>& themes,
                                            const std::vector<Core::FMTtransition>& trans,
                                            std::vector<Core::FMTaction>&actions,
                                            Core::FMTyields& yields,
                                            const int& constraintid) const;
        // DocString: FMTconstraint::canbeturnedtoyields
        bool canbeturnedtoyields() const;
        // DocString: FMTconstraint::turntoyieldsandactions
        void turntoyieldsandactions(const std::vector<Core::FMTtheme>& themes,
                         std::vector<Core::FMTaction>&actions,
                         Core::FMTyields& yields,
                         const int& constraintid) const;
    };
}
 
BOOST_CLASS_EXPORT_KEY(Core::FMTconstraint)
#endif