tableau.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 __TABLEAU__
#define __TABLEAU__

#include <exception>
#include "MatrixDouble.h"
#include "CoinPackedMatrix.hpp"

//auxiliary class for specially ordered set
class SpeciallyOrderedSet
{   
   public:
        int getType()const;
        int getPriority()const;
        int getNumberOfMembers()const;
        int* getColumnIndices()const;
        double* getDownPseudoCosts()const;
        double* getReferenceRow()const;
   
         virtual void print()const;
         virtual void readFile(FILE*);
         virtual void writeFile(FILE*)const;
         SpeciallyOrderedSet();
         SpeciallyOrderedSet(const SpeciallyOrderedSet&);
         SpeciallyOrderedSet& operator=(const SpeciallyOrderedSet&);
         virtual ~SpeciallyOrderedSet() {gutsOfDestructor(); }
   
   private:
         int numberofmembers;        //number of members in set
         int type;        //SOS type 1, 2, and 3 or type 4 (= integer set)
         int priority;        //priority
         int* columnindices;      //column indices
         double* downpseudocosts;  //down pseudocosts
         double* referencerow;  //reference row (in case of SOS type 1, 2, and 3) or up-pseudocosts (in case of integer set = SOS type 4)
   
         void gutsOfDestructor(){
                if(columnindices){
                        delete [] columnindices;
                        columnindices = NULL;
                }
                if(downpseudocosts)     {
                delete [] downpseudocosts;
                downpseudocosts = NULL;
                }
        if(referencerow){       
                delete [] referencerow;
                referencerow = NULL;
        }
         }
         template <class Type> void allocateVector(Type*& pointertovector, long int sizeofvector);
};

template <class Type>
void SpeciallyOrderedSet::allocateVector(Type*& pointertovector, long int sizeofvector){
        if (sizeofvector > 0)
                if(pointertovector== NULL){
                        try{
                                pointertovector= new Type[sizeofvector];
                        }
                        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];
                        }
                        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 cerr       << "Warning in "<< typeid(*this).name()<<"::allocateVector(): nothing to allocate:"
                                << "length of array of "<<typeid(*pointertovector).name()<<" is: "<<sizeofvector<<"!" << endl;
}

//neu 2004 column indices for performance indicators
typedef struct
{       int numA; //number of activities
        int col0; //first column index
} infoPerf;


//neu 2004 MILP fine-tuning parameters
typedef struct
{       int    rowLP;  //row (=constraint) index
        int    colLP;  //column (=activity) index
   double origV;  //original fine-tuned parameter
   double consV;        //parameter for consumption mode
} infoFine;


//neu 2004 TSPC model auxiliary structures -------------------------------------
typedef struct
{  //data per cropping activity
   int colLP;  //activity column in LP
   int colOp;  //output column in LP ("Preisertragsspalte")
   int typCr;  //type of crop (yes/no)
   int roYLD;  //grain yield row in LP
   int roYSM;  //stover energy row in LP

} infoTSPC;


typedef struct
{  int colStv;    //'stover fed to livestock' column in LP
} infoResi;

//------------------------------------------------------------------------------
//Auxiliary structure and class for LP tableau
typedef struct
{  int brows;     //start rows of block
   int bcols;     //start column of block
   MatrixDouble bctyp;  //block column types
   MatrixDouble bzrow;  //block z-row
   MatrixDouble bmat;   //block MatrixDouble
} matblock;


class tableau
{  protected:
   int numblx;       //Number of MatrixDouble blocks
   int trans;        //transposed (yes/no)
   matblock** matblx;//Pointer to MatrixDouble block pointers
   MatrixDouble infoblx;   //Matrix containing info for each block

   public:
   tableau();
   virtual ~tableau()
   {  deallocateTableau();
   }

   virtual void printToScreen();
   virtual void allocateTableau(int, int);
   virtual CoinPackedMatrix getInfoBlock();//added by lutz
   virtual void setInfoBlock(CoinPackedMatrix infoblock,int nrows, int ncols);// added by lutz
   virtual void readTableauFromFile(FILE* strm,
         MatrixDouble& ctx, MatrixDouble& zrx, MatrixDouble& mtx, int nrows, int ncols);
   virtual void writeTableauIntoFile(FILE* strm,
         const MatrixDouble& ctx, const MatrixDouble& zrx, const MatrixDouble& mtx);

   virtual void allocateBlock(int, int, int);
   virtual void readBlockFromFile(int, FILE*);
   virtual void writeBlockIntoFile(int, FILE*);

   virtual int getNumBlocks();
   virtual int getIfTrans();
   virtual void writeInfoblxInFile(FILE* strm);

   virtual void copyBlockIntoZRow(int bn, MatrixDouble& zrx, int zrxc);
   virtual void copyBlockIntoMatrix(int bn, MatrixDouble& mtx, int mtxr, int mtxc);

   virtual void copyZRowIntoBlock(int bn, const MatrixDouble& zrx, int zrxc);
   virtual void copyMatrixIntoBlock(int bn, const MatrixDouble& mtx, int mtxr, int mtxc);

   virtual void deallocateTableau();
   virtual void deallocateBlock(int);

};

#endif

#endif /* LP_OLD */

---