FMTSerializableMatrix.h

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 FMTserializablematrix_Hm_included
#define FMTserializablematrix_Hm_included
 
 
#include <memory>
#include <vector>
#include "FMTutility.h"
#include <boost/serialization/vector.hpp>
 
class OsiSolverInterface;
class CoinPackedMatrix;
 
namespace Models
{
// DocString: FMTSerializableMatrix
class FMTEXPORT FMTSerializableMatrix
    {
    // DocString: FMTSerializableMatrix::matrix
    std::unique_ptr<CoinPackedMatrix> matrix;
    // DocString: FMTSerializableMatrix::collb
    std::vector<double>collb;
    // DocString: FMTSerializableMatrix::colub
    std::vector<double>colub;
    // DocString: FMTSerializableMatrix::obj
    std::vector<double>obj;
    // DocString: FMTSerializableMatrix::rowlb
    std::vector<double>rowlb;
    // DocString: FMTSerializableMatrix::rowub
    std::vector<double>rowub;
    // DocString: FMTSerializableMatrix::colsolution
    std::vector<double>colsolution;
    // DocString: FMTSerializableMatrix::rowprice
    std::vector<double>rowprice;
    // DocString: FMTSerializableMatrix::serialize
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
        {
        const bool loading = Archive::is_loading::value;
        bool order;
        double extragap;
        double extramajor;
        int sizevector;
        int minordim;
        int numelements;
        int majordim;
        int maxsize;
        std::vector<double> lelement;
        std::vector<int> lindex;
        std::vector<int> llength;
        std::vector<int> lstart;
        //members
        std::vector<double> lcollb;
        std::vector<double> lcolub;
        std::vector<double> lobj;
        std::vector<double> lrowlb;
        std::vector<double> lrowub;
        std::vector<double> lcolsolution;
        std::vector<double> lrowprice;
        if (!loading)
        {
            getSetMatrixElements(false,
                order,
                extragap,
                extramajor,
                sizevector,
                minordim,
                numelements,
                majordim,
                maxsize,
                lelement,
                lindex,
                llength,
                lstart);
            getSetMemberElements(false,
                lcollb,
                lcolub,
                lobj,
                lrowlb,
                lrowub,
                lcolsolution,
                lrowprice);
        }
        ar&order;
        ar& extragap;
        ar& extramajor;
        ar& sizevector;
        ar& minordim;
        ar& numelements;
        ar& majordim;
        ar& maxsize;
        ar& lelement;
        ar& lindex;
        ar& llength;
        ar& lstart;
        //members
        ar& lcollb;
        ar& lcolub;
        ar& lobj;
        ar& lrowlb;
        ar& lrowub;
        ar& lcolsolution;
        ar& lrowprice;
        if (loading)
            {
            getSetMatrixElements(true,
                order,
                extragap,
                extramajor,
                sizevector,
                minordim,
                numelements,
                majordim,
                maxsize,
                lelement,
                lindex,
                llength,
                lstart);
            getSetMemberElements(true,
                lcollb,
                lcolub,
                lobj,
                lrowlb,
                lrowub,
                lcolsolution,
                lrowprice);
            }
        
 
        }
    // DocString: FMTSerializableMatrix::getSetMatrixElements
    void getSetMatrixElements(bool loading,
        bool& order,
        double& extragap,
        double& extramajor,
        int& sizevector,
        int& minordim,
        int& numelements,
        int& majordim,
        int& maxsize,
        std::vector<double>& lelement,
        std::vector<int>& lindex,
        std::vector<int>& llength,
        std::vector<int>& lstart);
    // DocString: FMTSerializableMatrix::getSetMemberElements
    void getSetMemberElements(bool loading,
        std::vector<double>&lcollb,
        std::vector<double>&lcolub,
        std::vector<double>&lobj,
        std::vector<double>&lrowlb,
        std::vector<double>&lrowub,
        std::vector<double>&lcolsolution,
        std::vector<double>&lrowprice);
    public:
        // DocString: FMTSerializableMatrix()
        FMTSerializableMatrix();
        // DocString: FMTSerializableMatrix(const FMTSerializableMatrix)
        FMTSerializableMatrix(const FMTSerializableMatrix& rhs);
        // DocString: FMTSerializableMatrix::operator=
        FMTSerializableMatrix& operator = (const FMTSerializableMatrix& rhs);
        // DocString: FMTSerializableMatrix(const std::shared_ptr<OsiSolverInterface>,const FMTSolverInterface)
        FMTSerializableMatrix(const std::shared_ptr<OsiSolverInterface>& solverinterface);
        // DocString: FMTSerializableMatrix::setSolverType
        //void setSolverType(FMTSolverInterface& lsolvertype) const;
        // DocString: FMTSerializableMatrix::setMatrix
        void setMatrix(std::shared_ptr<OsiSolverInterface>& solverinterface) const;
        // DocString: FMTSerializableMatrix::buildSolverInterface
        //std::shared_ptr<OsiSolverInterface> buildSolverInterface(const FMTSolverInterface& lsolvertype, CoinMessageHandler* handler) const;
        // DocString: FMTSerializableMatrix::copySolverInterface
        //std::shared_ptr<OsiSolverInterface> copySolverInterface(const std::shared_ptr<OsiSolverInterface>& solver_ptr, const FMTSolverInterface& lsolvertype, CoinMessageHandler* handler) const;
        // DocString: ~FMTSerializableMatrix()
        ~FMTSerializableMatrix();
    };
 
}
 
#endif
#endif