doxygen/html/FMTLpSolver_8h_source.html

/*

Copyright (c) 2019 Gouvernement du Qu�bec


SPDX-License-Identifier: LiLiQ-R-1.1

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

*/


#ifdef FMTWITHOSI

#ifndef FMTsolve_Hm_included

#define FMTsolve_Hm_included

#include "FMTSolverInterface.h"

#include "FMTMatrixBuild.h"

#include "FMTExceptionHandler.h"

#include "FMTObject.h"

#include <memory>

#include <unordered_map>

#include <string_view>

#include <boost/serialization/split_member.hpp>

#include <boost/serialization/export.hpp>

#include <boost/archive/binary_oarchive.hpp>

#include <boost/archive/binary_iarchive.hpp>

#include "FMTSerializableMatrix.h"


#if __has_include("OsiGlpkSolverInterface.hpp")

    #ifndef FMTWITHGLPK

        #define FMTWITHGLPK

    #endif

#endif


#if __has_include("OsiClpSolverInterface.hpp")

    #ifndef FMTWITHCLP

        #define FMTWITHCLP

    #endif

#endif


class OsiSolverInterface;

class CoinPackedMatrix;


namespace Models

{


// DocString: FMTLpSolver

class FMTEXPORT FMTLpSolver: public Core::FMTObject

    {

    public:

        // DocString: FMTLpSolver::swap

        void swap(FMTLpSolver& rhs);

        // DocString: FMTLpSolver::passInLogger

        void passInLogger(const std::unique_ptr<Logging::FMTLogger>& logger) override;

        // DocString: FMTLpSolver::unmarkHotStart

        void unmarkHotStart();

        // DocString: FMTLpSolver::stockResolve

        bool stockResolve();

        // DocString: FMTLpSolver()

        FMTLpSolver();

        // DocString: ~FMTLpSolver()

        virtual ~FMTLpSolver() = default;

        // DocString: FMTLpSolver(const FMTLpSolver&)

        FMTLpSolver(const FMTLpSolver& rhs);

        // DocString: FMTLpSolver(FMTLpSolver&&)

        FMTLpSolver(FMTLpSolver&& rhs)=default;

        // DocString: FMTLpSolver::operator=

        FMTLpSolver& operator =(const FMTLpSolver& rhs);

        // DocString: FMTLpSolver::operator=

        FMTLpSolver& operator =(FMTLpSolver&& rhs) =default;

        // DocString: FMTLpSolver(FMTSolverInterface,const std::string,const std::string)

        FMTLpSolver(FMTSolverInterface lsolvertype,

            const std::string& p_ColdStartParameters,

            const std::string& p_WarmStartParameters,

            const std::string& p_problemName);

        // DocString: FMTLpSolver::operator==

        bool operator == (const FMTLpSolver& rhs) const;

        // DocString: FMTLpSolver::operator!=

        bool operator != (const FMTLpSolver& rhs) const;

        // DocString: FMTLpSolver::resolve

        virtual bool resolve();

        // DocString: FMTLpSolver::initialSolve

        virtual bool initialSolve();

        // DocString: FMTLpSolver::setNumberOfThreads

        void setNumberOfThreads(const size_t& nthread);

        // DocString: FMTLpSolver::setMipGapTolerance

        void setMipGapTolerance(const double& gap);

        // DocString: FMTLpSolver::setOptimizerMaxTime

        void setOptimizerMaxTime(const double& time);

        // DocString: FMTLpSolver::setFeasiblePumpImprovSol

        void mipParameters();

        // DocString: FMTLpSolver::getObjValue

        double getObjValue() const;

        // DocString: FMTLpSolver::getIterationCount

        int getIterationCount() const;

        // DocString: FMTLpSolver::passInSolver

        void passInSolver(const FMTLpSolver& solver);

        // DocString: FMTLpSolver::passInMessageHandler

        void passInMessageHandler(Logging::FMTLogger& logger);

        // DocString: FMTLpSolver::setSolverType

        void setSolverType(FMTSolverInterface& lsolvertype) const;

        // DocString: FMTLpSolver::gotLicense

        bool gotLicense() const;

        // DocString: FMTLpSolver::getSolverName

        std::string getSolverName() const;

        // DocString: FMTLpSolver::getNumCols

        int getNumCols() const;

        // DocString: FMTLpSolver::getNumRows

        int getNumRows() const;

        // DocString: FMTLpSolver::getObjCoefficients

        const double* getObjCoefficients() const;

        // DocString: FMTLpSolver::getColLower

        const double* getColLower() const;

        // DocString: FMTLpSolver::getColUpper

        const double* getColUpper() const;

        // DocString: FMTLpSolver::getColSolution

        const double* getColSolution() const;

        // DocString: FMTLpSolver::getRowPrice

        const double* getRowPrice() const;

        // DocString: FMTLpSolver::getRowActivity

        const double* getRowActivity() const;

        // DocString: FMTLpSolver::getRowUpper

        const double* getRowUpper() const;

        // DocString: FMTLpSolver::getRowLower

        const double* getRowLower() const;

        // DocString: FMTLpSolver::getRow

        int getRow(int whichRow, double &rowLower, double &rowUpper,

            std::vector<int>& indices, std::vector<double>&elements) const;

        // DocString: FMTLpSolver::getCol

        int getCol(int whichCol, double &colLower, double &colUpper, double &objectiveValue,

            std::vector<int>& indices, std::vector<double>&elements) const;

        // DocString: FMTLpSolver::getObjSense

        double getObjSense() const;

        // DocString: FMTLpSolver::setObjective

        void setObjective(const double* objectivevalues);

        // DocString: FMTLpSolver::setObjSense

        void setObjSense(const double& newsense);

        // DocString: FMTLpSolver::addRow

        void addRow(int numberInRow, const int * columns, const double * elements,

            double rowLower = -std::numeric_limits<double>::max(), double rowUpper = std::numeric_limits<double>::max());

        // DocString: FMTLpSolver::addCol

        void addCol(int numberInColumn, const int * rows, const double * elements, double columnLower = 0.0,

            double columnUpper = std::numeric_limits<double>::max(), double objectiveValue = 0.0);

        // DocString: FMTLpSolver::addRows

        void addRows(const int numrows, const int* rowStarts, const int* columns,

            const double* elements, const double* rowlb, const double* rowub);

        // DocString: FMTLpSolver::addCols

        void addCols(const int numcols, const int* columnStarts, const int* rows,

            const double* elements, const double* collb, const double* colub, const double* obj);

        // DocString: FMTLpSolver::isProvenOptimal

        bool isProvenOptimal() const;

        // DocString: FMTLpSolver::deleteRow

        void deleteRow(const int& rowindex);

        // DocString: FMTLpSolver::deleteCol

        void deleteCol(const int& colindex);

        // DocString: FMTLpSolver::deleteRows

        void deleteRows(int numberofrows,const int* rowindexes);

        // DocString: FMTLpSolver::deleteCols

        void deleteCols(int numberofcols, const int* colindexes);

        // DocString: FMTLpSolver::setColSolution

        void setColSolution(const double* newsolution);

        // DocString: FMTLpSolver::setRowPrice

        void setRowPrice(const double* rowprice);

        // DocString: FMTLpSolver::setColSetBounds

        void setColSetBounds(const int* indexFirst, const int* indexLast, const double* boundlist);

        // DocString: FMTLpSolver::setRowSetBoundss

        void setRowSetBounds(const int* indexFirst, const int* indexLast, const double* boundlist);

        // DocString: FMTLpSolver::setInteger

        void setInteger(const int& colindex);

        // DocString: FMTLpSolver::setInteger

        void setInteger(const int* indices,int len);

        // DocString: FMTLpSolver::updateMatrixNaming

        //void updateMatrixNaming(const std::unordered_map<int, std::string>& colsnames,

        //  const std::unordered_map<int, std::string>& rownames);

        // DocString: FMTLpSolver::setColName

        void setColName(const std::string& name, const int& columnid) const;

        // DocString: FMTLpSolver::setRowName

        void setRowName(const std::string& name, const int& rowid) const;

        // DocString: FMTLpSolver::writeLp

        void writeLp(const std::string& location) const;

        // DocString: FMTLpSolver::writeMps

        void writeMps(const std::string& location) const;

        // DocString: FMTLpSolver::branchAndBound

        void branchAndBound();

        // DocString: FMTLpSolver::enableMatrixCaching

        void enableMatrixCaching();

        // DocString: FMTLpSolver::disableMatrixCaching

        void disableMatrixCaching();

        // DocString: FMTLpSolver::getSolverType()

        inline FMTSolverInterface getSolverType() const

        {

            return solvertype;

        }

        // DocString: FMTLpSolver::synchronize

        void synchronize();

        // DocString: FMTLpSolver::sortDeletedCache

        void sortDeletedCache();

        // DocString: FMTLpSolver::getCacheDeletedConstraints

        inline const std::vector<int>& getCacheDeletedConstraints() const

        {

            return matrixcache.getDeletedConstraints();

        }

        // DocString: FMTLpSolver::getcachedeletedvariable

        inline const std::vector<int>& getCacheDeletedVariables() const

        {

            return matrixcache.getDeletedVariables();

        }

        // DocString: FMTLpSolver::lowerNUpperToStr

        std::string lowerNUpperToStr(const double& lower, const double& upper) const;

        // DocString: FMTLpSolver::getCacheElements

        std::string getCacheElements() const;

        // DocString: FMTLpSolver::updateRowsAndColsNames

        void updateRowsAndColsNames(bool shortformat = true);

        // DocString: FMTLpSolver::getMskErrorDesc

        std::string getMskErrorDesc(int error) const;

        // DocString: FMTLpSolver::SupportsMultiThreading

        bool SupportsMultiThreading() const;

        // DocString: FMTLpSolver::getAvailableSolverInterface

        static std::vector<Models::FMTSolverInterface> getAvailableSolverInterface();

        // DocString: FMTLpSolver::toString

        static std::string_view toString(Models::FMTSolverInterface p_solver);

    protected:

        // DocString: FMTLpSolver::matrixcache

        mutable FMTMatrixBuild matrixcache;

        // DocString: FMTLpSolver::solvertype

        FMTSolverInterface solvertype;

        // DocString: FMTLpSolver::canUpdateSource

        bool canUpdateSource() const;

        // DocString: FMTLpSolver::buildSolverInterface

        std::shared_ptr<OsiSolverInterface> buildSolverInterface(const FMTSolverInterface& lsolvertype) const;

        // DocString: FMTLpSolver::copySolverInterface

        std::shared_ptr<OsiSolverInterface> copySolverInterface(const std::shared_ptr<OsiSolverInterface>& solver_ptr, const FMTSolverInterface& lsolvertype) const;

        // DocString: FMTLpSolver::clearRowCache

        void clearRowCache();

        // DocString: FMTLpSolver::getMatrixByRow

        const CoinPackedMatrix* getMatrixByRow() const;

        // DocString: FMTLpSolver::getMatrixByCol

        const CoinPackedMatrix* getMatrixByCol() const;

    private:

        // DocString: FMTLpSolver::strtoParams

        static std::vector<std::pair<std::string, std::string>>strtoParams(const std::string& p_params);

        friend class boost::serialization::access;

        // DocString: FMTLpSolver::save

        template<class Archive>

        void save(Archive& ar, const unsigned int version) const

        {

            try {

                ar& boost::serialization::make_nvp("FMTobject", boost::serialization::base_object<Core::FMTObject>(*this));

                ar& BOOST_SERIALIZATION_NVP(usecache);

                matrixcache.synchronize(solverinterface);

                const FMTSerializableMatrix matrix(solverinterface);

                ar& BOOST_SERIALIZATION_NVP(solvertype);

                ar& BOOST_SERIALIZATION_NVP(matrix);

            }

            catch (...)

            {

                _exhandler->raiseFromCatch("", "FMTLpSolver::save", __LINE__, __FILE__);

            }

        }

        // DocString: FMTLpSolver::load

        template<class Archive>

        void load(Archive& ar, const unsigned int version)

        {

            try {

                ar& boost::serialization::make_nvp("FMTobject", boost::serialization::base_object<FMTObject>(*this));

                ar& BOOST_SERIALIZATION_NVP(usecache);

                matrixcache.synchronize(solverinterface);

                FMTSerializableMatrix matrix;

                ar& BOOST_SERIALIZATION_NVP(solvertype);

                ar& BOOST_SERIALIZATION_NVP(matrix);

                solverinterface = this->buildSolverInterface(solvertype);

                matrix.setMatrix(solverinterface);

            }

            catch (...)

            {

                _exhandler->raiseFromCatch("", "FMTLpSolver::load", __LINE__, __FILE__);

            }


        }

        BOOST_SERIALIZATION_SPLIT_MEMBER()

        // DocString: FMTLpSolver::solverinterface

        std::shared_ptr<OsiSolverInterface>solverinterface;

        // DocString: FMTLpSolver::usecache

        bool usecache;

        // DocString: FMTLpSolver::>m_ColdStartParameters

        std::vector<std::pair<std::string, std::string>>m_ColdStartParameters;

        // DocString: FMTLpSolver::>m_WarmStartParameters

        std::vector<std::pair<std::string, std::string>>m_WarmStartParameters;

        // DocString: FMTLpSolver::_mskOptimizeWithParameters

        int _mskOptimizeWithParameters();

        // DocString: FMTLpSolver::_mskOptimizeWithDefaultParameters

        int _mskOptimizeWithDefaultParameters();

        // DocString: FMTLpSolver::_setGlpkLogLevel

        void _setGlpkLogLevel(Logging::FMTLogger& p_logger);

        // DocString: FMTLpSolver::_setClpOptions

        void _setClpOptions();

    };

}

BOOST_CLASS_EXPORT_KEY(Models::FMTLpSolver)

#endif

#endif

FMTExceptionHandler.h

FMTMatrixBuild.h

FMTObject.h

FMTSerializableMatrix.h

FMTEXPORT
#define FMTEXPORT
Definition: FMTutility.h:125

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

Logging::FMTLogger
Base class handling the level of information printed by FMT.
Definition: FMTLogger.h:37

Models::FMTLpSolver
Abstract class to ease the usage of the OsiSolverInterface in FMT for linear programming models.
Definition: FMTLpSolver.h:49

Models::FMTLpSolver::writeLp
void writeLp(const std::string &location) const
Write the solver interface matrix to a file using the LP formulation.

Models::FMTLpSolver::getObjValue
double getObjValue() const
Get the objective value of the solved matrix.

Models::FMTLpSolver::enableMatrixCaching
void enableMatrixCaching()
Enable the rows and columns caching when adding or deleting a variable to the solver interface,...

Models::FMTLpSolver::disableMatrixCaching
void disableMatrixCaching()
Synchronize the matrix cache with the solver interface and turn off the matrix caching.

Models::FMTLpSolver::clearRowCache
void clearRowCache()
Clear the row caching of the OsiSolverInterface if Mosek is used.

Models::FMTLpSolver::setColSetBounds
void setColSetBounds(const int *indexFirst, const int *indexLast, const double *boundlist)
Synchronize the matrix and set the lower and upper bounds of a set of columns.

Models::FMTLpSolver::getRowActivity
const double * getRowActivity() const
Return the row activity of the solver interface, without synchronizing with the cache.

Models::FMTLpSolver::setColSolution
void setColSolution(const double *newsolution)
Set a solution for all columns of the solver interface, synchronizing the matrix first.

Models::FMTLpSolver::swap
void swap(FMTLpSolver &rhs)
Swap this FMTLpSolver with another one.

Models::FMTLpSolver::setInteger
void setInteger(const int &colindex)
Synchronize the matrix and set a given column as integer.

Models::FMTLpSolver::updateRowsAndColsNames
void updateRowsAndColsNames(bool shortformat=true)
Update the rows and columns names.

Models::FMTLpSolver::deleteRows
void deleteRows(int numberofrows, const int *rowindexes)
Delete multiple rows; if the cache is used the matrix is synchronized before deleting the rows.

Models::FMTLpSolver::resolve
virtual bool resolve()
Call solverinterface->resolve when some changes are done to the model, avoiding a full initialSolve.

Models::FMTLpSolver::getCacheDeletedConstraints
const std::vector< int > & getCacheDeletedConstraints() const
Return the row ids that are in the cache and marked as deleted.
Definition: FMTLpSolver.h:514

Models::FMTLpSolver::stockResolve
bool stockResolve()
Call the plain OsiSolverInterface resolve, synchronizing the matrix first.

Models::FMTLpSolver::solvertype
FMTSolverInterface solvertype
Solver type used maybe usefull for initialSolve or resolve to know what solver we are using to speed-...
Definition: FMTLpSolver.h:579

Models::FMTLpSolver::synchronize
void synchronize()
Update the OsiSolverInterface using the cached matrix information (new or deleted rows and columns) w...

Models::FMTLpSolver::getNumCols
int getNumCols() const
Return the number of columns by looking in the solver interface and in the cache.

Models::FMTLpSolver::getSolverName
std::string getSolverName() const
Return the name of the solver used.

Models::FMTLpSolver::toString
static std::string_view toString(Models::FMTSolverInterface p_solver)
return the string value of the solver

Models::FMTLpSolver::writeMps
void writeMps(const std::string &location) const
Write the solver interface matrix to a file using the MPS formulation.

Models::FMTLpSolver::getCacheElements
std::string getCacheElements() const
Return the constraints and variables sitting in the matrix cache to be added to the solver interface,...

Models::FMTLpSolver::getColLower
const double * getColLower() const
Return the column lower bounds of the matrix, synchronizing the solver interface with the cache first...

Models::FMTLpSolver::addCol
void addCol(int numberInColumn, const int *rows, const double *elements, double columnLower=0.0, double columnUpper=std::numeric_limits< double >::max(), double objectiveValue=0.0)
Add a column with its rows, elements, bounds and objective value.

Models::FMTLpSolver::isProvenOptimal
bool isProvenOptimal() const
Return true if the program is optimal, synchronizing the matrix with the cache first.

Models::FMTLpSolver::getObjSense
double getObjSense() const
Return the objective sense of the solver interface, synchronizing with the cache first.

Models::FMTLpSolver::FMTLpSolver
FMTLpSolver(const FMTLpSolver &rhs)
Default copy constructor for FMTLpSolver.

Models::FMTLpSolver::getRow
int getRow(int whichRow, double &rowLower, double &rowUpper, std::vector< int > &indices, std::vector< double > &elements) const
Fill the bounds, indices and elements of a given row, trying to synchronize the matrix as little as p...

Models::FMTLpSolver::getColUpper
const double * getColUpper() const
Return the column upper bounds of the matrix, synchronizing the solver interface with the cache first...

Models::FMTLpSolver::setColName
void setColName(const std::string &name, const int &columnid) const
Update the constraints and variables names.

Models::FMTLpSolver::addRow
void addRow(int numberInRow, const int *columns, const double *elements, double rowLower=-std::numeric_limits< double >::max(), double rowUpper=std::numeric_limits< double >::max())
Add a row with its columns, elements and bounds.

Models::FMTLpSolver::~FMTLpSolver
virtual ~FMTLpSolver()=default
Default virtual destructor for FMTLpSolver.

Models::FMTLpSolver::passInSolver
void passInSolver(const FMTLpSolver &solver)
Share the solver interface pointer of another solver.

Models::FMTLpSolver::setRowName
void setRowName(const std::string &name, const int &rowid) const
Set a row name.

Models::FMTLpSolver::getAvailableSolverInterface
static std::vector< Models::FMTSolverInterface > getAvailableSolverInterface()
Return the available solver interfaces.

Models::FMTLpSolver::getObjCoefficients
const double * getObjCoefficients() const
Return the objective coefficients of the matrix, synchronizing the solver interface with the cache fi...

Models::FMTLpSolver::passInMessageHandler
void passInMessageHandler(Logging::FMTLogger &logger)
Pass the FMTLogger to the solver interface.

Models::FMTLpSolver::deleteRow
void deleteRow(const int &rowindex)
Delete a given row; if the cache is used it is only deleted from the cache.

Models::FMTLpSolver::matrixcache
FMTMatrixBuild matrixcache
The matrix cache follow the constraints or variables that need to be added or removed to the problem.
Definition: FMTLpSolver.h:576

Models::FMTLpSolver::initialSolve
virtual bool initialSolve()
Cold start of the LP solve of a simple LP model.

Models::FMTLpSolver::addRows
void addRows(const int numrows, const int *rowStarts, const int *columns, const double *elements, const double *rowlb, const double *rowub)
Add multiple rows directly to the matrix, synchronizing the matrix with the cache first.

Models::FMTLpSolver::lowerNUpperToStr
std::string lowerNUpperToStr(const double &lower, const double &upper) const
Convert double bounds to string bounds (-inf, inf).

Models::FMTLpSolver::mipParameters
void mipParameters()
Set the mixed-integer optimizer parameters, including the way the feasibility pump heuristic is emplo...

Models::FMTLpSolver::setObjective
void setObjective(const double *objectivevalues)
Set the objective values of the columns of the matrix.

Models::FMTLpSolver::setOptimizerMaxTime
void setOptimizerMaxTime(const double &time)
Set the maximum amount of time the optimizer is allowed to spend on the optimization.

Models::FMTLpSolver::getSolverType
FMTSolverInterface getSolverType() const
Return the solver type of the solver.
Definition: FMTLpSolver.h:495

Models::FMTLpSolver::unmarkHotStart
void unmarkHotStart()
Clear all cached data in the OsiSolverInterface.

Models::FMTLpSolver::setRowSetBounds
void setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundlist)
Synchronize the matrix and set the lower and upper bounds of a set of rows.

Models::FMTLpSolver::FMTLpSolver
FMTLpSolver(FMTLpSolver &&rhs)=default
Default move constructor for FMTLpSolver.

Models::FMTLpSolver::getNumRows
int getNumRows() const
Return the number of rows by looking in the solver interface and in the cache.

Models::FMTLpSolver::addCols
void addCols(const int numcols, const int *columnStarts, const int *rows, const double *elements, const double *collb, const double *colub, const double *obj)
Add multiple columns directly to the matrix, synchronizing the matrix with the cache first.

Models::FMTLpSolver::canUpdateSource
bool canUpdateSource() const
Return true if the solver interface source can be updated.

Models::FMTLpSolver::deleteCols
void deleteCols(int numberofcols, const int *colindexes)
Delete multiple columns; if the cache is used the matrix is synchronized before deleting the columns.

Models::FMTLpSolver::branchAndBound
void branchAndBound()
Synchronize the matrix cache and call the branch and bound MIP enumeration solver.

Models::FMTLpSolver::buildSolverInterface
std::shared_ptr< OsiSolverInterface > buildSolverInterface(const FMTSolverInterface &lsolvertype) const
Build a shared pointer to a solver interface, passing the message handler to the pointer.

Models::FMTLpSolver::getCol
int getCol(int whichCol, double &colLower, double &colUpper, double &objectiveValue, std::vector< int > &indices, std::vector< double > &elements) const
Fill the bounds, objective, indices and elements of a given column, trying to synchronize the matrix ...

Models::FMTLpSolver::gotLicense
bool gotLicense() const
Return true if the license of the solver is available.

Models::FMTLpSolver::SupportsMultiThreading
bool SupportsMultiThreading() const
Return true if the solver support multithreading.

Models::FMTLpSolver::getMatrixByRow
const CoinPackedMatrix * getMatrixByRow() const
Return a CoinPackedMatrix by row of the problem, synchronizing the matrix first.

Models::FMTLpSolver::setRowPrice
void setRowPrice(const double *rowprice)
Set a solution for all rows of the solver interface, synchronizing the matrix first.

Models::FMTLpSolver::getRowPrice
const double * getRowPrice() const
Return the row price (dual solution) of the solver interface, without synchronizing with the cache.

Models::FMTLpSolver::deleteCol
void deleteCol(const int &colindex)
Delete a given column; if the cache is used it is only deleted from the cache.

Models::FMTLpSolver::FMTLpSolver
FMTLpSolver(FMTSolverInterface lsolvertype, const std::string &p_ColdStartParameters, const std::string &p_WarmStartParameters, const std::string &p_problemName)
Main constructor for FMTLpSolver with a solver type, cold and warm start parameters and a problem nam...

Models::FMTLpSolver::getMskErrorDesc
std::string getMskErrorDesc(int error) const
Return the description of an error code from Mosek.

Models::FMTLpSolver::setSolverType
void setSolverType(FMTSolverInterface &lsolvertype) const
Setter of the solver type of the serializable matrix.

Models::FMTLpSolver::setObjSense
void setObjSense(const double &newsense)
Set the objective sense of the solver interface.

Models::FMTLpSolver::getColSolution
const double * getColSolution() const
Return the column solution of the solver interface, without synchronizing with the cache.

Models::FMTLpSolver::setInteger
void setInteger(const int *indices, int len)
Synchronize the matrix and set multiple columns as integer variables.

Models::FMTLpSolver::getCacheDeletedVariables
const std::vector< int > & getCacheDeletedVariables() const
Return the column ids that are in the cache and marked as deleted.
Definition: FMTLpSolver.h:523

Models::FMTLpSolver::setMipGapTolerance
void setMipGapTolerance(const double &gap)
Set the tolerance between the relaxed optimal and the integer optimal.

Models::FMTLpSolver::getMatrixByCol
const CoinPackedMatrix * getMatrixByCol() const
Return a CoinPackedMatrix by column of the problem, synchronizing the matrix first.

Models::FMTLpSolver::FMTLpSolver
FMTLpSolver()
Default constructor for FMTLpSolver.

Models::FMTLpSolver::getRowLower
const double * getRowLower() const
Return the row lower bounds of the solver interface, synchronizing with the cache first.

Models::FMTLpSolver::sortDeletedCache
void sortDeletedCache()
Sort and remove duplicates in the rows and columns to delete in the matrix cache.

Models::FMTLpSolver::setNumberOfThreads
void setNumberOfThreads(const size_t &nthread)
Set the maximum number of threads to be used by the solver.

Models::FMTLpSolver::copySolverInterface
std::shared_ptr< OsiSolverInterface > copySolverInterface(const std::shared_ptr< OsiSolverInterface > &solver_ptr, const FMTSolverInterface &lsolvertype) const
Copy a shared pointer to a solver interface into another shared pointer, passing the message handler ...

Models::FMTLpSolver::getRowUpper
const double * getRowUpper() const
Return the row upper bounds of the solver interface, synchronizing with the cache first.

Models::FMTLpSolver::passInLogger
void passInLogger(const std::unique_ptr< Logging::FMTLogger > &logger) override
Pass in the logger, overridden for the OsiSolverInterface.

Models::FMTLpSolver::getIterationCount
int getIterationCount() const
Get the number of iterations done by the solver.

Models::FMTMatrixBuild
Helper caching rows and columns to add to a solver matrix in batch for efficiency.
Definition: FMTMatrixBuild.h:32

Models::FMTMatrixBuild::synchronize
void synchronize(std::shared_ptr< OsiSolverInterface > solver)
Synchronize the cached columns and rows with the solver matrix.

Models::FMTSerializableMatrix
Helper for the serialization of an OSI solver interface matrix.
Definition: FMTSerializableMatrix.h:29

Logging
Namespace for the log management, provides different log handlers.
Definition: FMTDebugLogger.h:14

Models
Namespace containing all enumerator and classes used to construct or manipulate the different type of...
Definition: FMTAreaParser.h:54

Models::FMTSolverInterface
FMTSolverInterface
Enumerator used to specify the solver to use when solving the FMTLpModel.
Definition: FMTsolverinterface.h:21

boost::serialization::load
void load(Ar &ar, dynamic_bitset< Block, Alloc > &bs, unsigned)
Definition: FMTMask.h:53

std
STL namespace.