doxygen/html/RexportModel_8hpp_source.html

/*

Copyright (c) 2019 Gouvernement du Qu�bec


SPDX-License-Identifier: LiLiQ-R-1.1

License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt

*/


#ifndef REXPORTMODEL_H_INCLUDED

#define REXPORTMODEL_H_INCLUDED


#include "FMTmodel.hpp"

#include "FMTsrmodel.hpp"

#include "FMTlpmodel.hpp"

#include "FMTsemodel.hpp"

#include "FMTsesmodel.hpp"

#include "FMTnssmodel.hpp"

#include "FMTsamodel.hpp"

#include "FMTlpsolver.hpp"

#include "Rdefinitions.hpp"

#include "FMTsolverinterface.hpp"

#include <Rcpp.h>

#include <string>


RCPP_EXPOSED_WRAP(Models::FMTmodel);

RCPP_EXPOSED_AS(Models::FMTmodel);

RCPP_DEFINEVECTOR(Models::FMTmodel);//For vector

RCPP_DEFINEMAP(std::string,double);//For map<string,double>

RCPP_EXPOSED_WRAP(Models::FMTsemodel);

RCPP_EXPOSED_AS(Models::FMTsemodel);

RCPP_DEFINEVECTOR(Models::FMTsemodel);//For vector

RCPP_EXPOSED_WRAP(Models::FMTsesmodel);

RCPP_EXPOSED_AS(Models::FMTsesmodel);

RCPP_DEFINEVECTOR(Models::FMTsesmodel);//For vector

#ifdef FMTWITHOSI

    RCPP_EXPOSED_WRAP(Models::FMTsrmodel);

    RCPP_EXPOSED_AS(Models::FMTsrmodel);

    RCPP_DEFINEVECTOR(Models::FMTsrmodel);//For vector

    RCPP_EXPOSED_WRAP(Models::FMTnssmodel);

    RCPP_EXPOSED_AS(Models::FMTnssmodel);

    RCPP_DEFINEVECTOR(Models::FMTnssmodel);//For vector

    RCPP_EXPOSED_ENUM_NODECL(Models::FMTsolverinterface);

    RCPP_EXPOSED_WRAP(Models::FMTlpsolver);

    RCPP_EXPOSED_AS(Models::FMTlpsolver);

    RCPP_DEFINEVECTOR(Models::FMTlpsolver);//For vector

    RCPP_EXPOSED_WRAP(Models::FMTlpmodel);

    RCPP_EXPOSED_AS(Models::FMTlpmodel);

    RCPP_DEFINEVECTOR(Models::FMTlpmodel);//For vector

#endif


RCPP_EXPOSED_WRAP(Models::FMTsamodel);

RCPP_EXPOSED_AS(Models::FMTsamodel);

RCPP_DEFINEVECTOR(Models::FMTsamodel);//For vector


RCPP_EXPOSED_ENUM_NODECL(Models::FMTintmodelparameters);

RCPP_EXPOSED_ENUM_NODECL(Models::FMTdblmodelparameters);

RCPP_EXPOSED_ENUM_NODECL(Models::FMTboolmodelparameters);


namespace R

{


void exportModel()

{

    Rcpp::class_<Models::FMTmodel>("FMTmodel", "@DocString(FMTmodel)")

        .derives<Core::FMTobject>("FMTobject")

        .constructor<Models::FMTmodel>("@DocString(FMTmodel(Models::FMTmodel))")

        .constructor("@DocString(FMTmodel())")

           .method("getname",&Models::FMTmodel::getname,

                "@DocString(FMTmodel::getname)")

            .method("getyields",&Models::FMTmodel::getyields,

                "@DocString(FMTmodel::getyields)")

            .method("setyields", &Models::FMTmodel::setyields,

                "@DocString(FMTmodel::setyields)")

            .method("getarea",&Models::FMTmodel::getarea,

                "@DocString(FMTmodel::getarea)")

            .method("setarea", &Models::FMTmodel::setarea,

                "@DocString(FMTmodel::setarea)")

            .method("getthemes",&Models::FMTmodel::getthemes,

                "@DocString(FMTmodel::getthemes)")

            .method("setthemes", &Models::FMTmodel::setthemes,

                "@DocString(FMTmodel::setthemes)")

            .method("getactions",&Models::FMTmodel::getactions,

                "@DocString(FMTmodel::getactions)")

            .method("setactions", &Models::FMTmodel::setactions,

                "@DocString(FMTmodel::setactions)")

            .method("getoutputs", &Models::FMTmodel::getoutputs,

                "@DocString(FMTmodel::getoutputs)")

            .method("setoutputs", &Models::FMTmodel::setoutputs,

                "@DocString(FMTmodel::setoutputs)")

            .method("getconstraints", &Models::FMTmodel::getconstraints,

                "@DocString(FMTmodel::getconstraints)")

            .method("setconstraints", &Models::FMTmodel::setconstraints,

                "@DocString(FMTmodel::setconstraints)")

            .method("gettransitions",&Models::FMTmodel::gettransitions,

                "@DocString(FMTmodel::gettransitions)")

            .method("settransitions",&Models::FMTmodel::settransitions,

                "@DocString(FMTmodel::settransitions)")

            .method("setname", &Models::FMTmodel::setname,

                "@DocString(FMTmodel::setname)")

            .method("setareaperiod", &Models::FMTmodel::setareaperiod,

                "@DocString(FMTmodel::setareaperiod)")

            .method("getlifespan",&Models::FMTmodel::getlifespan,

                "@DocString(FMTmodel::getlifespan)")

            .method("setlifespan", &Models::FMTmodel::setlifespan,

                "@DocString(FMTmodel::setlifespan)")

            .method("isvalid",&Models::FMTmodel::isvalid,

                "@DocString(FMTmodel::isvalid)")

            .method("getpostsolvefilter", &Models::FMTmodel::getpostsolvefilter,

                "@DocString(FMTmodel::getpostsolvefilter)")

            .method("isoptimal", &Models::FMTmodel::isoptimal,

                "@DocString(FMTmodel::isoptimal)")

            .method("getobjectivevalue", &Models::FMTmodel::getobjectivevalue,

                "@DocString(FMTmodel::getobjectivevalue)")

            .method("setboolparameter",

                static_cast<bool(Models::FMTmodel::*)(const Models::FMTboolmodelparameters&, const bool&)>(&Models::FMTmodel::setparameter),

                "@DocString(Models::FMTmodel::setparameter(const FMTboolmodelparameters,const bool))")

            .method("setintparameter",

                static_cast<bool(Models::FMTmodel::*)(const Models::FMTintmodelparameters&, const int&)>(&Models::FMTmodel::setparameter),

                "@DocString(Models::FMTmodel::setparameter(const FMTintmodelparameters,const int))")

            .method("setdblparameter",

                static_cast<bool(Models::FMTmodel::*)(const Models::FMTdblmodelparameters&, const double&)>(&Models::FMTmodel::setparameter),

                "@DocString(Models::FMTmodel::setparameter(const FMTdblmodelparameters,const int))")

            .method("showparameters",&Models::FMTmodel::showparameters,

            "@DocString(FMTmodel::showparameters)")

            .method("doplanning",&Models::FMTmodel::doplanning,

                "@DocString(FMTmodel::doplanning)");


    Rcpp::class_<Models::FMTsemodel>("FMTsemodel", "@DocString(FMTsemodel)")

        .derives<Models::FMTmodel>("FMTmodel")

        .constructor("@DocString(FMTsemodel())")

        .constructor<Models::FMTmodel>("@DocString(FMTsemodel(Models::FMTmodel))")

        .method("getmapping", &Models::FMTsemodel::getmapping,

            "@DocString(FMTsemodel::getmapping)")

        .method("getschedule", &Models::FMTsemodel::getschedule,

            "@DocString(FMTsemodel::getschedule)")

        .method("getspschedule", &Models::FMTsemodel::getspschedule,

            "@DocString(FMTsemodel::getdisturbances)")

        .method("setinitialmapping", &Models::FMTsemodel::setinitialmapping,

            "@DocString(FMTsemodel::setinitialmapping)")

        .method("getspatialoutput", &Models::FMTsemodel::getspatialoutput,

            "@DocString(FMTsemodel::getschedule)")

        .method("getdisturbancestats", &Models::FMTsemodel::getdisturbancestats,

            "@DocString(FMTsemodel::getdisturbancestats)");


    Rcpp::class_<Models::FMTsesmodel>("FMTsesmodel", "@DocString(FMTsesmodel)")

        .derives<Models::FMTsemodel>("FMTsemodel")

        .constructor("@DocString(FMTsesmodel())")

        .constructor<Models::FMTmodel>("@DocString(FMTsesmodel(Models::FMTmodel))")

        .method("greedyreferencebuild", &Models::FMTsesmodel::greedyreferencebuild,

            "@DocString(FMTsesmodel:::greedyreferencebuild)");


    #ifdef FMTWITHOSI

    Rcpp::class_<Models::FMTlpsolver>("FMTlpsolver", "@DocString(FMTlpsolver)")

        .constructor("@DocString(FMTlpsolver())")

        .method("isProvenOptimal", &Models::FMTlpsolver::isProvenOptimal,

            "@DocString(FMTlpsolver::isProvenOptimal)")

        .method("getObjValue", &Models::FMTlpsolver::getObjValue,

            "@DocString(FMTlpsolver::getObjValue)")

        .method("writeLP", &Models::FMTlpsolver::writeLP,

            "@DocString(FMTlpsolver::writeLP)")

        .method("writeMPS", &Models::FMTlpsolver::writeMPS,

            "@DocString(FMTlpsolver::writeMPS)");


    Rcpp::class_<Models::FMTsrmodel>("FMTsrmodel", "@DocString(FMTsrmodel)")

        .derives<Models::FMTmodel>("FMTmodel")

        .constructor("@DocString(FMTsrmodel())")

        .method("buildperiod", &Models::FMTsrmodel::buildperiod,

            "@DocString(FMTsrmodel::buildperiod)")

        .method("boundsolution", &Models::FMTsrmodel::boundsolution,

            "@DocString(FMTsrmodel::boundsolution)")

        .method("getsolution", &Models::FMTsrmodel::getsolution,

            "@DocString(FMTsrmodel::getsolution)")

        .method("setsolution", &Models::FMTsrmodel::setsolution,

            "@DocString(FMTsrmodel::setsolution)")

        .method("setsolutionbylp", &Models::FMTsrmodel::setsolutionbylp,

            "@DocString(FMTsrmodel::setsolutionbylp)")

        .method("getoutputsdataframe", &Models::FMTsrmodel::getoutputsdataframe,

            "@DocString(FMTsrmodel::getoutputsdataframe)")

        .method("getoutput", &Models::FMTsrmodel::getoutput,

            "@DocString(FMTsrmodel::getoutput)")

        .method("getstats", &Models::FMTsrmodel::getstats,

            "@DocString(FMTsrmodel::getstats)");


    Rcpp::class_<Models::FMTnssmodel>("FMTnssmodel", "@DocString(FMTnssmodel)")

        .derives<Models::FMTsrmodel>("FMTsrmodel")

        .constructor("@DocString(FMTnssmodel())")

        .constructor<Models::FMTmodel, unsigned int>("@DocString(FMTnssmodel(Models::FMTmodel,unsigned int))")

        .method("simulate", &Models::FMTnssmodel::simulate,

            "@DocString(FMTnssmodel::simulate)");


    Rcpp::class_<Models::FMTlpmodel>("FMTlpmodel", "@DocString(FMTlpmodel)")

        .derives<Models::FMTsrmodel>("FMTsrmodel")

        .constructor<Models::FMTmodel, Models::FMTsolverinterface>("@DocString(FMTlpmodel(Models::FMTmodel,Models::FMTsolverinterface))")

        .constructor("@DocString(FMTlpmodel())")

        .constructor<Models::FMTlpmodel>("@DocString(FMTlpmodel(const FMTlpmodel&))")

        .method("setobjective", &Models::FMTlpmodel::setobjective,

            "@DocString(FMTlpmodel::setobjective)")

        .method("setconstraint", &Models::FMTlpmodel::setconstraint,

            "@DocString(FMTlpmodel::setconstraint)")

        .method("eraseconstraint", &Models::FMTlpmodel::eraseconstraint,

            "@DocString(FMTlpmodel::eraseconstraint)")

        .method("eraseperiod", &Models::FMTlpmodel::eraseperiod,

            "@DocString(FMTlpmodel::eraseperiod)")

        .method("resolve", &Models::FMTlpmodel::resolve,

            "@DocString(FMTlpmodel::resolve)")

        .method("initialsolve", &Models::FMTlpmodel::initialsolve,

            "@DocString(FMTlpmodel::initialsolve)")

        .method("eq", &Models::FMTlpmodel::operator ==,

            "@DocString(FMTlpmodel::operator==)")

        .method("ne", &Models::FMTlpmodel::operator !=,

            "@DocString(FMTlpmodel::operator!=)")

        .method("getoperatingareaschedulerheuristics", &Models::FMTlpmodel::getoperatingareaschedulerheuristics,

            "@DocString(FMTlpmodel::getoperatingareaschedulerheuristics)")

        .method("getvariabilities", &Models::FMTlpmodel::getvariabilities,

            "@DocString(FMTlpmodel::getvariabilities)")

        .method("getareavariabilities", &Models::FMTlpmodel::getareavariabilities,

            "@DocString(FMTlpmodel::getareavariabilities)")

        .method("writeLP", &Models::FMTlpmodel::writeLP,

            "@DocString(FMTlpmodel::writeLP)")

        .method("setstrictlypositivesoutputsmatrix", &Models::FMTlpmodel::setstrictlypositivesoutputsmatrix,

            "@DocString(FMTlpmodel::setstrictlypositivesoutputsmatrix)")

        .method("getObjValue", &Models::FMTlpmodel::getObjValue,

                    "@DocString(FMTlpmodel::getObjValue)")

        .method("writeMPS", &Models::FMTlpmodel::writeMPS,

            "@DocString(FMTlpmodel::writeMPS)");;


    #endif


    Rcpp::class_<Models::FMTsamodel>("FMTsamodel", "@DocString(FMTsamodel)")

        .derives<Models::FMTsemodel>("FMTmodel")

        .constructor<Models::FMTmodel>("@DocString(FMTsamodel(FMTmodel))")

        .constructor("@DocString(FMTsamodel())")

        .method("initialsolve", &Models::FMTsamodel::initialsolve,

            "@DocString(FMTsamodel::initialsolve)");


    }

}

#endif // PYEXPORTMODEL_H_INCLUDED

FMTlpmodel.hpp

FMTlpsolver.hpp

FMTmodel.hpp

FMTnssmodel.hpp

FMTsamodel.hpp

FMTsemodel.hpp

FMTsesmodel.hpp

FMTsolverinterface.hpp

FMTsrmodel.hpp

Rdefinitions.hpp

RCPP_EXPOSED_WRAP
RCPP_EXPOSED_WRAP(Models::FMTmodel)

RCPP_EXPOSED_AS
RCPP_EXPOSED_AS(Models::FMTmodel)

RCPP_DEFINEVECTOR
RCPP_DEFINEVECTOR(Models::FMTmodel)

RCPP_DEFINEMAP
RCPP_DEFINEMAP(std::string, double)

RCPP_EXPOSED_ENUM_NODECL
RCPP_EXPOSED_ENUM_NODECL(Models::FMTsolverinterface)

Core::FMTobject
Definition: FMTobject.hpp:50

Models::FMTlpmodel
Definition: FMTlpmodel.hpp:57

Models::FMTlpmodel::writeMPS
void writeMPS(const std::string &location)

Models::FMTlpmodel::eraseconstraint
Graph::FMTgraphstats eraseconstraint(const Core::FMTconstraint &constraint, int period=-1)

Models::FMTlpmodel::eraseperiod
Graph::FMTgraphstats eraseperiod(bool constraintsonly=false)

Models::FMTlpmodel::initialsolve
bool initialsolve()

Models::FMTlpmodel::setconstraint
Graph::FMTgraphstats setconstraint(const Core::FMTconstraint &constraint)

Models::FMTlpmodel::writeLP
void writeLP(const std::string &location)

Models::FMTlpmodel::setobjective
Graph::FMTgraphstats setobjective(const Core::FMTconstraint &objective)

Models::FMTlpmodel::setstrictlypositivesoutputsmatrix
void setstrictlypositivesoutputsmatrix()

Models::FMTlpmodel::getvariabilities
std::map< std::string, std::vector< double > > getvariabilities(const std::vector< Core::FMToutput > &outputs, const int &periodstart, const int &periodstop)

Models::FMTlpmodel::getObjValue
double getObjValue() const

Models::FMTlpmodel::getoperatingareaschedulerheuristics
std::vector< Heuristics::FMToperatingareascheduler > getoperatingareaschedulerheuristics(const std::vector< Heuristics::FMToperatingareascheme > &opareas, const Core::FMToutputnode &node, size_t numberofheuristics=1, bool copysolver=true)

Models::FMTlpmodel::resolve
bool resolve()

Models::FMTlpmodel::getareavariabilities
std::map< std::string, std::vector< double > > getareavariabilities(const std::vector< Core::FMToutput > &localoutputs, const std::vector< Core::FMTmask > &globalmasks, std::vector< double > tolerances=std::vector< double >()) const

Models::FMTlpsolver
Definition: FMTlpsolver.hpp:39

Models::FMTlpsolver::isProvenOptimal
bool isProvenOptimal() const

Models::FMTlpsolver::getObjValue
double getObjValue() const

Models::FMTlpsolver::writeLP
void writeLP(const std::string &location) const

Models::FMTlpsolver::writeMPS
void writeMPS(const std::string &location) const

Models::FMTmodel
Definition: FMTmodel.hpp:60

Models::FMTmodel::setname
void setname(const std::string &newname)

Models::FMTmodel::setyields
void setyields(const Core::FMTyields &lylds)

Models::FMTmodel::getlifespan
Core::FMTlifespans getlifespan() const
Definition: FMTmodel.hpp:233

Models::FMTmodel::setparameter
virtual bool setparameter(const FMTintmodelparameters &key, const int &value)

Models::FMTmodel::setconstraints
void setconstraints(const std::vector< Core::FMTconstraint > &lconstraint)

Models::FMTmodel::getname
std::string getname() const
Definition: FMTmodel.hpp:193

Models::FMTmodel::setarea
void setarea(const std::vector< Core::FMTactualdevelopment > &ldevs)

Models::FMTmodel::getoutputs
std::vector< Core::FMToutput > getoutputs() const
Definition: FMTmodel.hpp:241

Models::FMTmodel::getyields
Core::FMTyields getyields() const
Definition: FMTmodel.hpp:225

Models::FMTmodel::isoptimal
virtual bool isoptimal() const

Models::FMTmodel::gettransitions
std::vector< Core::FMTtransition > gettransitions() const
Definition: FMTmodel.hpp:217

Models::FMTmodel::showparameters
virtual void showparameters(const bool &showhelp=false) const

Models::FMTmodel::getpostsolvefilter
Core::FMTmaskfilter getpostsolvefilter(const std::vector< Core::FMTtheme > &originalthemes, const Core::FMTmask &devmask) const

Models::FMTmodel::getactions
std::vector< Core::FMTaction > getactions() const
Definition: FMTmodel.hpp:209

Models::FMTmodel::getthemes
std::vector< Core::FMTtheme > getthemes() const
Definition: FMTmodel.hpp:201

Models::FMTmodel::getarea
virtual std::vector< Core::FMTactualdevelopment > getarea(int period=0, bool beforegrowanddeath=false) const

Models::FMTmodel::isvalid
bool isvalid()

Models::FMTmodel::setareaperiod
void setareaperiod(const int &period)

Models::FMTmodel::setlifespan
void setlifespan(const Core::FMTlifespans &llifespan)

Models::FMTmodel::settransitions
void settransitions(const std::vector< Core::FMTtransition > &ltransitions)

Models::FMTmodel::setoutputs
void setoutputs(const std::vector< Core::FMToutput > &newoutputs)

Models::FMTmodel::setactions
void setactions(const std::vector< Core::FMTaction > &lactions)

Models::FMTmodel::doplanning
virtual bool doplanning(const bool &solve, std::vector< Core::FMTschedule > schedules=std::vector< Core::FMTschedule >())

Models::FMTmodel::getobjectivevalue
virtual double getobjectivevalue() const

Models::FMTmodel::setthemes
void setthemes(const std::vector< Core::FMTtheme > &lthemes)

Models::FMTmodel::getconstraints
std::vector< Core::FMTconstraint > getconstraints() const
Definition: FMTmodel.hpp:249

Models::FMTnssmodel
Definition: FMTnssmodel.hpp:31

Models::FMTnssmodel::simulate
void simulate()

Models::FMTsamodel
Definition: FMTsamodel.hpp:44

Models::FMTsamodel::initialsolve
bool initialsolve()

Models::FMTsemodel
Definition: FMTsemodel.hpp:33

Models::FMTsemodel::getspatialoutput
virtual Spatial::FMTlayer< double > getspatialoutput(const Core::FMToutput &output, int period) const

Models::FMTsemodel::getdisturbancestats
std::string getdisturbancestats() const

Models::FMTsemodel::getschedule
std::vector< Core::FMTschedule > getschedule(bool withlock=false) const

Models::FMTsemodel::getspschedule
Spatial::FMTspatialschedule getspschedule() const
Definition: FMTsemodel.hpp:100

Models::FMTsemodel::getmapping
Spatial::FMTforest getmapping() const

Models::FMTsemodel::setinitialmapping
bool setinitialmapping(Spatial::FMTforest forest)

Models::FMTsesmodel
Definition: FMTsesmodel.hpp:28

Models::FMTsesmodel::greedyreferencebuild
std::map< std::string, double > greedyreferencebuild(const Core::FMTschedule &schedule, const size_t &randomiterations, unsigned int seed=0, double tolerance=FMT_DBL_TOLERANCE)

Models::FMTsrmodel
Definition: FMTsrmodel.hpp:44

Models::FMTsrmodel::setsolutionbylp
bool setsolutionbylp(int period, const Core::FMTschedule &schedule, double tolerance=FMT_DBL_TOLERANCE)

Models::FMTsrmodel::buildperiod
Graph::FMTgraphstats buildperiod(Core::FMTschedule schedule=Core::FMTschedule(), bool forcepartialbuild=false, int compressageclassoperability=1)

Models::FMTsrmodel::getstats
Graph::FMTgraphstats getstats() const

Models::FMTsrmodel::boundsolution
bool boundsolution(int period, double tolerance=FMT_DBL_TOLERANCE)

Models::FMTsrmodel::getoutput
virtual std::map< std::string, double > getoutput(const Core::FMToutput &output, int period, Core::FMToutputlevel level=Core::FMToutputlevel::standard) const

Models::FMTsrmodel::setsolution
bool setsolution(int period, const Core::FMTschedule &schedule, double tolerance=FMT_DBL_TOLERANCE)

Models::FMTsrmodel::getsolution
Core::FMTschedule getsolution(int period, bool withlock=false) const final

Models::FMTdblmodelparameters
FMTdblmodelparameters
Definition: FMTmodelparameters.hpp:37

Models::FMTsolverinterface
FMTsolverinterface
Definition: FMTsolverinterface.hpp:21

Models::FMTintmodelparameters
FMTintmodelparameters
Definition: FMTmodelparameters.hpp:24

Models::FMTboolmodelparameters
FMTboolmodelparameters
Definition: FMTmodelparameters.hpp:45

R
Definition: RexportCore.hpp:153

R::exportModel
void exportModel()
Definition: RexportModel.hpp:61