doxygen/html/RexportHeuristics_8h_source.html

/*

Copyright (c) 2019 Gouvernement du Qu�bec


SPDX-License-Identifier: LiLiQ-R-1.1

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

*/


#ifndef REXPORTHEURISTICS_H_INCLUDED

#define REXPORTHEURISTICS_H_INCLUDED


#include "FMTOperatingArea.h"

#include "FMTOperatingAreaClusterBinary.h"

#include "FMTOperatingAreaCluster.h"

#include "FMTOperatingAreaClusterer.h"

#include "FMTOperatingAreaScheduler.h"

#include "FMTOperatingAreaScheme.h"

#include "FMTLpSolver.h"

#include "Rdefinitions.h"

#include <Rcpp.h>


#ifdef FMTWITHOSI

    RCPP_EXPOSED_WRAP(Heuristics::FMTOperatingArea);

    RCPP_EXPOSED_AS(Heuristics::FMTOperatingArea);

    RCPP_DEFINEVECTOR(Heuristics::FMTOperatingArea);//For vector

    RCPP_EXPOSED_WRAP(Heuristics::FMTOperatingAreaScheme);

    RCPP_EXPOSED_AS(Heuristics::FMTOperatingAreaScheme);

    RCPP_DEFINEVECTOR(Heuristics::FMTOperatingAreaScheme);//For vector

    RCPP_EXPOSED_WRAP(Heuristics::FMTOperatingAreaScheduler);

    RCPP_EXPOSED_AS(Heuristics::FMTOperatingAreaScheduler);

    RCPP_DEFINEVECTOR(Heuristics::FMTOperatingAreaScheduler);//For vector

    RCPP_EXPOSED_WRAP(Heuristics::FMTOperatingAreaClusterBinary);

    RCPP_EXPOSED_AS(Heuristics::FMTOperatingAreaClusterBinary);

    RCPP_DEFINEVECTOR(Heuristics::FMTOperatingAreaClusterBinary);//For vector

    RCPP_EXPOSED_WRAP(Heuristics::FMTOperatingAreaCluster);

    RCPP_EXPOSED_AS(Heuristics::FMTOperatingAreaCluster);

    RCPP_DEFINEVECTOR(Heuristics::FMTOperatingAreaCluster);//For vector

    RCPP_EXPOSED_WRAP(Heuristics::FMTOperatingAreaClusterer);

    RCPP_EXPOSED_AS(Heuristics::FMTOperatingAreaClusterer);

    RCPP_DEFINEVECTOR(Heuristics::FMTOperatingAreaClusterer);//For vector

#endif


namespace R

{

void exportHeuristics()

{


    #ifdef FMTWITHOSI


    Rcpp::class_<Heuristics::FMTOperatingArea>("FMToperatingarea", "@DocString(FMTOperatingArea)")

        .constructor("@DocString(FMTOperatingArea())")

        .constructor<Core::FMTMask,double>("@DocString(FMTOperatingArea(const Core::FMTMask&,const double&))")

        .method("getneighbors", &Heuristics::FMTOperatingArea::getNeighbors,

            "@DocString(FMTOperatingArea::getneighbors)")

        .method("setneighbors", &Heuristics::FMTOperatingArea::setNeighbors,

            "@DocString(FMTOperatingArea::setneighbors)")

        .method("getmask", &Heuristics::FMTOperatingArea::getMask,

            "@DocString(FMTOperatingArea::getmask)")

        .method("getneihgborsperimeter", &Heuristics::FMTOperatingArea::getNeighborsPerimeter,

            "@DocString(FMTOperatingArea::getneihgborsperimeter)");


    Rcpp::class_<Heuristics::FMTOperatingAreaCluster>("FMToperatingareacluster", "@DocString(FMTOperatingAreaCluster)")

        .constructor("@DocString(FMTOperatingAreaCluster())")

        .constructor<Heuristics::FMTOperatingAreaCluster,double,double>("@DocString(FMTOperatingAreaCluster(const FMTOperatingAreaCluster&,const double&,const double&))")

        .method("getfilteredcluster",&Heuristics::FMTOperatingAreaCluster::getFilteredCluster,

             "@DocString(FMTOperatingAreaCluster::getfilteredcluster)")

        .method("getallmasks",&Heuristics::FMTOperatingAreaCluster::getAllMasks,

             "@DocString(FMTOperatingAreaCluster::getallmasks)")

        .method("setminimalarea",&Heuristics::FMTOperatingAreaCluster::setMinimalArea,

             "@DocString(FMTOperatingAreaCluster::setminimalarea)")

        .method("setmaximalarea",&Heuristics::FMTOperatingAreaCluster::setMaximalArea,

             "@DocString(FMTOperatingAreaCluster::setmaximalarea)");


    Rcpp::class_<Heuristics::FMTOperatingAreaScheme>("FMToperatingareascheme", "@DocString(FMTOperatingAreaScheme)")

        .derives<Heuristics::FMTOperatingArea>("FMToperatingarea")

        .constructor("@DocString(FMTOperatingAreaScheme())")

        .constructor<Heuristics::FMTOperatingArea,size_t,size_t,size_t,size_t,size_t,size_t>("@DocString(FMTOperatingAreaScheme(const Heuristics::FMTOperatingArea&,const size_t&,const size_t&,const size_t&, const size_t&, const size_t&,double,bool))");


    Rcpp::class_<Heuristics::FMTLpHeuristic>("FMTlpheuristic", "@DocString(FMTLpHeuristic)")

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

        .constructor("@DocString(FMTLpHeuristic())");


    Rcpp::class_<Heuristics::FMTOperatingAreaScheduler>("FMToperatingareascheduler","@DocString(FMTOperatingAreaScheduler)")

        .derives<Heuristics::FMTLpHeuristic>("FMTlpheuristic")

        //.derives<Models::FMTLpSolver>("FMTlpsolver")

        .constructor("@DocString(FMTOperatingAreaScheduler())")

        .method("initialsolve", &Heuristics::FMTOperatingAreaScheduler::initialSolve,

            "@DocString(FMTOperatingAreaScheduler::initialsolve)")

        .method("branchnboundsolve", &Heuristics::FMTOperatingAreaScheduler::branchNBoundSolve,

            "@DocString(FMTOperatingAreaScheduler::branchnboundsolve)")

        .method("getsolution", &Heuristics::FMTOperatingAreaScheduler::getSolution,

            "@DocString(FMTOperatingAreaScheduler::getsolution)");


    Rcpp::class_<Heuristics::FMTOperatingAreaClusterer>("FMToperatingareaclusterer", "@DocString(FMTOperatingAreaClusterer)")

        .derives<Heuristics::FMTLpHeuristic>("FMTlpheuristic")

        .constructor("@DocString(FMTOperatingAreaClusterer())")

        .method("initialsolve", &Heuristics::FMTOperatingAreaClusterer::initialSolve,

            "@DocString(FMTOperatingAreaClusterer::initialsolve)")

        .method("branchnboundsolve", &Heuristics::FMTOperatingAreaClusterer::branchNBoundSolve,

            "@DocString(FMTOperatingAreaClusterer::branchnboundsolve)")

        .method("getsolution", &Heuristics::FMTOperatingAreaClusterer::getSolution,

            "@DocString(FMTOperatingAreaClusterer::getsolution)");


    #endif

    }

}

#endif

FMTLpSolver.h

FMTOperatingAreaClusterBinary.h

FMTOperatingAreaCluster.h

FMTOperatingAreaClusterer.h

FMTOperatingAreaScheduler.h

FMTOperatingAreaScheme.h

FMTOperatingArea.h

Rdefinitions.h

RCPP_EXPOSED_AS
RCPP_EXPOSED_AS(Heuristics::FMTOperatingArea)

RCPP_EXPOSED_WRAP
RCPP_EXPOSED_WRAP(Heuristics::FMTOperatingArea)

RCPP_DEFINEVECTOR
RCPP_DEFINEVECTOR(Heuristics::FMTOperatingArea)

Core::FMTMask
Core class holding, as a boost dynamic bitset, which theme attributes are part of a mask.
Definition: FMTMask.h:96

Core::FMTObject
Base class of multiple FMT classes holding a shared exception handler pointer and logger.
Definition: FMTObject.h:49

Heuristics::FMTLpHeuristic
Base class for solving LP and MIP problems using a heuristic, holding a random generator and its own ...
Definition: FMTLpHeuristic.h:34

Heuristics::FMTOperatingAreaClusterBinary
Definition of a non clustered operating area, used by the FMTOperatingAreaCluster.
Definition: FMTOperatingAreaClusterBinary.h:32

Heuristics::FMTOperatingAreaCluster
Potential cluster of multiple operating areas.
Definition: FMTOperatingAreaCluster.h:27

Heuristics::FMTOperatingAreaCluster::setMinimalArea
void setMinimalArea(const double &newminimalarea)
Set the minimal area of the cluster.

Heuristics::FMTOperatingAreaCluster::getFilteredCluster
FMTOperatingAreaCluster getFilteredCluster(const Core::FMTMask &filterMask) const
Return a cluster with the binaries not falling in a mask definition removed, which can reduce the num...

Heuristics::FMTOperatingAreaCluster::setMaximalArea
void setMaximalArea(const double &newmaximalarea)
Set the potential maximal area of the cluster.

Heuristics::FMTOperatingAreaCluster::getAllMasks
std::vector< Core::FMTMask > getAllMasks() const
Return all the masks contained by the cluster, including the operating area centroid.

Heuristics::FMTOperatingAreaClusterer
Heuristic to do spatial clustering of operating areas across a landscape from a shapefile.
Definition: FMTOperatingAreaClusterer.h:28

Heuristics::FMTOperatingAreaClusterer::getSolution
std::vector< FMTOperatingAreaCluster > getSolution() const
Return the clustering solution with cleaned operating clusters.

Heuristics::FMTOperatingAreaClusterer::initialSolve
bool initialSolve() final
Solve the heuristic problem using the fire spread heuristic to get a good initial clustering solution...

Heuristics::FMTOperatingAreaClusterer::branchNBoundSolve
bool branchNBoundSolve() final
Solve the problem using branch and bound on the primal formulation, using the heuristic solution as a...

Heuristics::FMTOperatingAreaScheduler
Heuristic to solve the spatialization problem across a landscape for multiple operating areas.
Definition: FMTOperatingAreaScheduler.h:57

Heuristics::FMTOperatingAreaScheduler::branchNBoundSolve
bool branchNBoundSolve() final
Solve the problem using branch and bound on the primal formulation, using the heuristic solution as a...

Heuristics::FMTOperatingAreaScheduler::initialSolve
bool initialSolve() final
Solve the heuristic problem until an initial solution is found for each operating area.

Heuristics::FMTOperatingAreaScheduler::getSolution
std::vector< Core::FMTTimeYieldHandler > getSolution(const std::string &yldname) const
Return the actual solution as a vector of time yield handlers, one per operating area.

Heuristics::FMTOperatingAreaScheme
Operating area scheme giving information about its opening time, green up and return time.
Definition: FMTOperatingAreaScheme.h:42

Heuristics::FMTOperatingArea
Operating area giving information about its mask, neighbors and neighbors perimeter.
Definition: FMTOperatingArea.h:29

Heuristics::FMTOperatingArea::getNeighborsPerimeter
double getNeighborsPerimeter() const
Return the percentage of perimeter the operating area needs to share with another operating area to b...

Heuristics::FMTOperatingArea::getNeighbors
std::vector< Core::FMTMask > getNeighbors() const
Return a copy of the neighbors masks of the operating area.

Heuristics::FMTOperatingArea::setNeighbors
void setNeighbors(const std::vector< Core::FMTMask > &lneighbors)
Set the neighbors masks of the operating area.

Heuristics::FMTOperatingArea::getMask
Core::FMTMask getMask() const
Return the mask of the operating area.

R
Definition: RexportCore.h:153

R::exportHeuristics
void exportHeuristics()
Definition: RexportHeuristics.h:45