FMTlpsolver.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
*/
 
#ifdef FMTWITHOSI
#ifndef FMTsolve_H_INCLUDED
#define FMTsolve_H_INCLUDED
#include "FMTsolverinterface.hpp"
#include "FMTmatrixbuild.hpp"
#include "FMTexceptionhandler.hpp"
#include "FMTobject.hpp"
#include <memory>
#include <unordered_map>
#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.hpp"
 
 
class OsiSolverInterface;
class CoinPackedMatrix;
 
namespace Models
{
 
// DocString: FMTlpsolver
class FMTEXPORT FMTlpsolver: public Core::FMTobject
    {
    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;
    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;
    public:
        // DocString: FMTlpsolver::swap
        void swap(FMTlpsolver& rhs);
        // DocString: FMTlpsolver::passinlogger
        void passinlogger(const std::shared_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,Logging::FMTlogger&)
        FMTlpsolver(FMTsolverinterface lsolvertype/*,Logging::FMTlogger& logger*/);
        // 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::deleteRow
        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);
        #ifdef FMTWITHMOSEK
            // DocString: FMTlpsolver::getmskerrordesc
            std::string getmskerrordesc(int error) const;
        #endif
    };
}
BOOST_CLASS_EXPORT_KEY(Models::FMTlpsolver)
#endif
#endif