AgentSolution.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 AGENTSOLUTION_H_
#define AGENTSOLUTION_H_

#include <typeinfo>

#include "OsiSymSolverInterface.hpp"
#include "SymWarmStart.hpp"
#include "CoinWarmStartBasis.hpp"


class AgentSolution
{
public:

        int getNumberOfRows()const;
        int getNumberOfColumns()const;
        double* getColumnSolution()const;
        double getColumnSolution(int index)const;
        double* getObjectiveFunctCoeff()const;
        double getObjectiveFunctCoeff(int index)const;
        double getObjValue()const;
        
        double* getDualRightHandSide()const;
        
        double getDualRightHandSide(int index)const;
        double* getSlackRightHandSide()const;
        double getSlackRightHandSide(int index)const;
        double* getRowActivity()const;
        double getRowActivity(int index)const;
        bool getTestFlag()const;
        double getInfinity() const;  
        double getTolerance()const;
        
        SymWarmStart* getWarmStartSym()const;
        CoinWarmStartBasis* getWarmStartCoin()const;
        //----------------------------------------------------------------------------------

        virtual void setNumberOfRows(const int numberofrows);
        virtual void setNumberOfColumns(const int numberofcolumns);
        virtual void setColumnSolution(const double* columnsolution_);
        virtual int setColumnSolution(const double value,int index);
        virtual void setObjectiveFunctCoeff(const double*objectivefunctcoeff_);
        virtual int setObjectiveFunctCoeff(const double value,int index);
        virtual void setObjValue(const double objvalue_);
        virtual void setDualRightHandSide(const double*dualrhs_);
        virtual int setDualRightHandSide(const double value,int index);
        virtual void setSlackRightHandSide(const double*slackrhs_);
        virtual int setSlackRightHandSide(const double value,int index);
        virtual void setRowActivity(const double*rowactivities_);
        virtual int setRowActivity(const double value,int index);
        virtual void setInfinity(double infinity);
        virtual void setTestFlag(bool test);
        virtual void setTolerance(double eps);
          
        virtual void setWarmStart(const SymWarmStart* const warmstart);
        virtual void setWarmStart(const CoinWarmStartBasis* const warmstart);
        
        virtual void load(      const int numberofrows_, const int numberofcolumns_, const double*columnsolution_,const double*objectivefunctcoeff_,
                                                const double objvalue_, const double*dualrhs_,const double*slackrhs_,const double*rowactivities_,
                                                const SymWarmStart* warmstart);
        virtual void load(      const int numberofrows_, const int numberofcolumns_, const double*columnsolution_,const double*objectivefunctcoeff_,
                                                const double objvalue_, const double*dualrhs_,const double*slackrhs_,const double*rowactivities_,
                                                const CoinWarmStartBasis* warmstart);
        //--------------------------------------------------------------------------------------------------------------------


        AgentSolution();
        AgentSolution(int numberofrows_, int numberofcols_);
        AgentSolution(const AgentSolution& solution);
        AgentSolution& operator=(const AgentSolution& rhs);
        virtual ~AgentSolution();
//----------------------------------------------------------------------------------------------------------------------
private:


        int numberofrows;
        int numberofcolumns;
        mutable double*  columnsolution;
        mutable double* objectivefunctcoeff;
    double objvalue;
        mutable double* dualrhs;
        mutable double* slackrhs;
        mutable double* rowactivities;
   double infinity;
        bool test;
        double eps;
        
        SymWarmStart* lastYearWarmStartSym;
        CoinWarmStartBasis* lastYearWarmStartCoin;
        //}@
        //--------------------------------------------------------------------------------------


        void round();
        void round(double* vector,int vectorlength);
        void round(CoinPackedMatrix *MatrixDouble);
        double round(double value);
        double truncate(double precision,double& x);
        double round(int numberofdecimals_, double& x);
        void gutsOfConstructor();
        void gutsOfDestructor();
        void allocate();
        template <class Type> int allocateVector(Type*& pointertovector, long int sizeofvector);
        template <class ClassType> void copy(ClassType*& finalObjectPtr_, const ClassType* const originalObjectPtr_);
};
//allocates memory for an array of type Type with size sizefovector and checks if size is positive  
template <class Type>
int AgentSolution::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
}

//Allocates memory for class member finalObjectPtr_ if necessary and copies data from the object originalObjectPtr_ points to
template <class ClassType> void AgentSolution::copy(ClassType*& finalObjectPtr_, const ClassType* const originalObjectPtr_){
        if (originalObjectPtr_ != NULL){
                if (finalObjectPtr_ == NULL)
                        try {
                                finalObjectPtr_ = new ClassType(*originalObjectPtr_);
                        }
                        catch (exception& exceptionObject){
                                cerr << "Exception: "<< exceptionObject.what() << endl;
                                cerr << "Error in "<< typeid(*this).name()<<"::copy(): cannot allocate memory for"<< typeid(ClassType).name()  << endl;
                        }
                else {
                        delete finalObjectPtr_;
                        finalObjectPtr_ = NULL;
                        try {
                                finalObjectPtr_ = new ClassType(*originalObjectPtr_);
                        }
                        catch (exception& exceptionObject){
                                cerr << "Exception: "<< exceptionObject.what() << endl;
                                cerr << "Error in "<< typeid(*this).name()<<"::copy(): cannot allocate memory for"<< typeid(ClassType).name() << endl;
                        }
                }
        }
        else if (test) cerr << "Warning in "<< typeid(*this).name() << "::copy():  "<<typeid(originalObjectPtr_).name() <<"  == NULL!" << endl;
}


#endif /*AGENTSOLUTION_H_*/
#endif /* LP_OLD*/

---