OsiOslSolverMipHandlerInterface.h

Go to the documentation of this file.

/*Copyright (C) 2006/2007, Professorship (p.p.) for Land Use Economics in the Tropics and
Subtropics, Institute for Agricultural Economics and Social Sciences in the Tropics
and Subtropics, University of Hohenheim, Stuttgart
Thomas Berger, Lutz Göhring
All rights reserved
*/
#ifndef LP_OLD
#ifndef OSIOSLSOLVERMIPHANDLERINTERFACE_H_
#define OSIOSLSOLVERMIPHANDLERINTERFACE_H_

//------------------------------------------------------------------------------
#ifdef TIMER
#ifdef AIX
//      #include <sys/types.h>
        #include <ctime>
   time_t t_0;     // start time step
   time_t t_1;     // first time step
#else 
        #include <bcd.h>
        #include <conio.h>
        struct  time t_0;
        struct  time t_1;
#endif
#endif
//------------------------------------------------------------------------------
#include "OsiOslSolverInterface.hpp"
#include "tableau.h"


class OsiOslSolverMipHandlerInterface : public OsiOslSolverInterface{
         friend void OsiOslSolverMipHandlerInterfaceUnitTest();//for testing
public:


        
        virtual int solve1();
        
        virtual int solve2();
        
        virtual int solve3();

        /*The following functions overwrite the base class to account for the recovery of column and row names 
        * after deletion of column and rows, respectively
        * */
        //{@
        
        virtual const double * getRowUpper() ;
        virtual const double * getObjCoefficients() ;

        /*The following functions overwrite the base class to account for the recovery of column and row names 
        * after deletion of column and rows, respectively
        * */
        //{@
        virtual const double * getColSolution() ;
        virtual const double * getRowPrice() ;
        virtual const double * getRowActivity() ;

        //{@
        int getNumberOfNodes();


        int getMaximumNumberOfNodes();
        bool getTestFlag()const;
        bool getTransponeFlag()const;


        CoinPackedMatrix getInfoBlock()const;


        void setTestFlag(bool test_);
        void setTransponeFlag(bool istransposed_);


        void setInfoBlock(CoinPackedMatrix infoBlock_);
        //---------------------------------------------------------------------------

        void deleteCols(const int num, const int * columnIndices);
        void deleteRows(const int num, const int * rowIndices);


        virtual void createNames();
         //---------------------------------------------------------------------------

    virtual void loadProblem(const int numcols, const int numrows,
                             const CoinBigIndex * start, const int* index,
                             const double* value,
                             const double* collb, const double* colub,   
                             const double* obj,
                             const double* rowlb, const double* rowub);

    virtual void loadProblem(const int numcols, const int numrows,
                             const CoinBigIndex * start, const int* index,
                             const double* value,
                             const double* collb, const double* colub,   
                             const double* obj,
                             const char* rowsen, const double* rowrhs,   
                             const double* rowrng);
        
        virtual int addSpeciallyOrderedSet(const SpeciallyOrderedSet* sos);                  
        

        virtual void writeProblemExcel(char* filename, const CoinPackedMatrix& activityType);

        //{@
        int testModel();
        int checkSolutionPrimal();


        OsiOslSolverMipHandlerInterface();
//      OsiOslSolverMipHandlerInterface(OsiOslSolverMipHandlerInterface& solverInterface);
        virtual ~OsiOslSolverMipHandlerInterface();
        
private:
        //number of rows of original model (i.e. before rows and cols are deleted)
        int numrows;
        //number of cols of original model (i.e. before rows and cols are deleted)
        int numcols;
        int numberofrowstodrop;      
        int numberofcolstodrop;
        bool test;
        int istransposed;  
        CoinPackedMatrix infoBlock;
 
        template <class Type> int allocateVector(Type*& pointertovector, long int sizeofvector);
        void retrieveOriginalColumnNames(int*& colIndex);
        void retrieveOriginalRowNames(int*& rowIndex);
        int checkColumns();
        int fixDiverseParameters();
        void gutsOfDestructor();
};
 
//allocates memory for an array of type Type with size sizefovector and checks if size is positive  
template <class Type>
int OsiOslSolverMipHandlerInterface::allocateVector(Type*& pointertovector, long int sizeofvector){
        if (sizeofvector > 0)
                if(pointertovector== NULL){
                        try{
                                pointertovector = new Type[sizeofvector];
                                for (int i = 0; i<sizeofvector;i++) pointertovector[i] = NULL;
                        }
                        catch(exception& exceptionObject){
                                cerr << "Exception: "<< exceptionObject.what()<<endl;
                                cerr << "Error in "<< typeid(*this).name()<<"::allocateVector(): cannot allocate memory for Type"<< typeid(*pointertovector).name()<<"["<<sizeofvector<<"]" << endl;
                                exit(0);
                        }
                }
                else {
                        delete[] pointertovector;
                        pointertovector = NULL;
                        try{
                                pointertovector = new Type[sizeofvector];
                                for (int i = 0; i<sizeofvector;i++) pointertovector[i] = NULL;
                        }
                        catch(exception& exceptionObject){
                                cerr << "Exception: "<< exceptionObject.what()<<endl;
                                cerr << "Error in "<< typeid(*this).name()<<"::allocateVector(): cannot allocate memory for Type"<< typeid(*pointertovector).name()<<"["<<sizeofvector<<"]" << endl;
                                exit(0);
                        }
                }
        else {
                if (test) cerr  << "Warning in "<< typeid(*this).name()<<"::allocateVector(): nothing to allocate:"
                                                << "length of array of "<<typeid(*pointertovector).name()<<" is: "<<sizeofvector<<"!" << endl;
                return 0;//failure/warning
        }
        return 1;//success
}
#endif /*OSIOSLSOLVERMIPHANDLERINTERFACE_H_*/
#endif /* LP_OLD*/

---