FMTserializablematrix.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 FMTserializablematrix_H_INCLUDED
#define FMTserializablematrix_H_INCLUDED
 
 
#include <memory>
#include <vector>
#include "FMTutility.hpp"
#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);
            }
        
 
        }
    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);
    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