AbcMatrix.hpp

Go to the documentation of this file.

/* $Id: AbcMatrix.hpp 1910 2013-01-27 02:00:13Z stefan $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others, Copyright (C) 2012, FasterCoin.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef AbcMatrix_H
#define AbcMatrix_H

#include "CoinPragma.hpp"

#include "ClpMatrixBase.hpp"
#include "AbcSimplex.hpp"
#include "CoinAbcHelperFunctions.hpp"
class AbcMatrix2;
class AbcMatrix3;
class AbcMatrix {
  
public:
  inline CoinPackedMatrix * getPackedMatrix() const {
    return matrix_;
  }
  inline bool isColOrdered() const {
    return true;
  }
  inline CoinBigIndex getNumElements() const {
    return matrix_->getNumElements();
  }
  inline int getNumCols() const {
    assert(matrix_->getNumCols()==model_->numberColumns());return matrix_->getNumCols();
  }
  inline int getNumRows() const {
    assert(matrix_->getNumRows()==model_->numberRows());return matrix_->getNumRows();
  }
  void setModel(AbcSimplex * model);
  inline const double * getElements() const {
    return matrix_->getElements();
  }
  inline double * getMutableElements() const {
    return matrix_->getMutableElements();
  }
  inline const int * getIndices() const {
    return matrix_->getIndices();
  }
  inline int * getMutableIndices() const {
    return matrix_->getMutableIndices();
  }
  inline const CoinBigIndex * getVectorStarts() const {
    return matrix_->getVectorStarts();
  }
  inline  CoinBigIndex * getMutableVectorStarts() const {
    return matrix_->getMutableVectorStarts();
  }
  inline const int * getVectorLengths() const {
    return matrix_->getVectorLengths();
  }
  inline int * getMutableVectorLengths() const {
    return matrix_->getMutableVectorLengths();
  }
  CoinBigIndex * rowStart() const;
  CoinBigIndex * rowEnd() const;
  double * rowElements() const;
  CoinSimplexInt * rowColumns() const;
  CoinPackedMatrix * reverseOrderedCopy() const;
  CoinBigIndex countBasis(const int * whichColumn,
                          int & numberColumnBasic);
  void fillBasis(const int * whichColumn,
                 int & numberColumnBasic,
                 int * row, int * start,
                 int * rowCount, int * columnCount,
                 CoinSimplexDouble * element);
  void fillBasis(const int * whichColumn,
                 int & numberColumnBasic,
                 int * row, int * start,
                 int * rowCount, int * columnCount,
                 long double * element);
  void scale(int numberRowsAlreadyScaled);
  void createRowCopy();
  void takeOutOfUseful(int sequence,CoinIndexedVector & spare);
  void putIntofUseful(int sequence,CoinIndexedVector & spare);
  void inOutUseful(int sequenceIn,int sequenceOut);
  void makeAllUseful(CoinIndexedVector & spare);
  void sortUseful(CoinIndexedVector & spare);
  void moveLargestToStart();
  
  void unpack(CoinIndexedVector & rowArray,
              int column) const ;
  void add(CoinIndexedVector & rowArray, int column, double multiplier) const ;
  
  void timesModifyExcludingSlacks(double scalar,
             const double * x, double * y) const;
  void timesModifyIncludingSlacks(double scalar,
             const double * x, double * y) const;
  void timesIncludingSlacks(double scalar,
             const double * x, double * y) const;
  void transposeTimesNonBasic(double scalar,
                            const double * x, double * y) const;
  void transposeTimesAll(const double * x, double * y) const;
  void transposeTimesBasic(double scalar,
                            const double * x, double * y) const;
  int transposeTimesNonBasic(double scalar,
                      const CoinIndexedVector & x,
                      CoinIndexedVector & z) const;
  double dualColumn1(const CoinIndexedVector & update,
                     CoinPartitionedVector & tableauRow,
                     CoinPartitionedVector & candidateList) const;
  double dualColumn1Row(int iBlock, double upperThetaSlack, int & freeSequence,
                        const CoinIndexedVector & update,
                        CoinPartitionedVector & tableauRow,
                        CoinPartitionedVector & candidateList) const;
  double dualColumn1RowFew(int iBlock, double upperThetaSlack, int & freeSequence,
                         const CoinIndexedVector & update,
                         CoinPartitionedVector & tableauRow,
                         CoinPartitionedVector & candidateList) const;
  double dualColumn1Row2(double upperThetaSlack, int & freeSequence,
                         const CoinIndexedVector & update,
                         CoinPartitionedVector & tableauRow,
                         CoinPartitionedVector & candidateList) const;
  double dualColumn1Row1(double upperThetaSlack, int & freeSequence,
                         const CoinIndexedVector & update,
                         CoinPartitionedVector & tableauRow,
                         CoinPartitionedVector & candidateList) const;
  void dualColumn1Part(int iBlock,int & sequenceIn, double & upperTheta,
                         const CoinIndexedVector & update,
                         CoinPartitionedVector & tableauRow,
                         CoinPartitionedVector & candidateList) const;
  void rebalance() const;
  int pivotColumnDantzig(const CoinIndexedVector & updates,
                         CoinPartitionedVector & spare) const; 
  int pivotColumnDantzig(int iBlock,bool doByRow,const CoinIndexedVector & updates,
                         CoinPartitionedVector & spare,
                         double & bestValue) const; 
  int primalColumnRow(int iBlock,bool doByRow,const CoinIndexedVector & update,
                          CoinPartitionedVector & tableauRow) const;
  int primalColumnRowAndDjs(int iBlock,const CoinIndexedVector & updateTableau,
                          const CoinIndexedVector & updateDjs,
                            CoinPartitionedVector & tableauRow) const;
  int chooseBestDj(int iBlock,const CoinIndexedVector & infeasibilities, 
                   const double * weights) const;
  int primalColumnDouble(int iBlock,CoinPartitionedVector & updateForTableauRow,
                          CoinPartitionedVector & updateForDjs,
                          const CoinIndexedVector & updateForWeights,
                          CoinPartitionedVector & spareColumn1,
                          double * infeasibilities, 
                          double referenceIn, double devex,
                          // Array for exact devex to say what is in reference framework
                          unsigned int * reference,
                          double * weights, double scaleFactor) const;
  int primalColumnSparseDouble(int iBlock,CoinPartitionedVector & updateForTableauRow,
                          CoinPartitionedVector & updateForDjs,
                          const CoinIndexedVector & updateForWeights,
                          CoinPartitionedVector & spareColumn1,
                          double * infeasibilities, 
                          double referenceIn, double devex,
                          // Array for exact devex to say what is in reference framework
                          unsigned int * reference,
                          double * weights, double scaleFactor) const;
  int primalColumnDouble(CoinPartitionedVector & updateForTableauRow,
                         CoinPartitionedVector & updateForDjs,
                         const CoinIndexedVector & updateForWeights,
                         CoinPartitionedVector & spareColumn1,
                         CoinIndexedVector & infeasible, 
                         double referenceIn, double devex,
                         // Array for exact devex to say what is in reference framework
                         unsigned int * reference,
                         double * weights, double scaleFactor) const;
  void primalColumnSubset(int iBlock,const CoinIndexedVector & update,
                          const CoinPartitionedVector & tableauRow,
                          CoinPartitionedVector & weights) const;
  void partialPricing(double startFraction, double endFraction,
                      int & bestSequence, int & numberWanted);
  void subsetTransposeTimes(const CoinIndexedVector & x,
                            CoinIndexedVector & z) const;
  void transposeTimes(const CoinIndexedVector & x,
                            CoinIndexedVector & z) const;
  
  inline CoinPackedMatrix * matrix() const {
    return matrix_;
  }
  inline int minimumObjectsScan() const {
    return minimumObjectsScan_;
  }
  inline void setMinimumObjectsScan(int value) {
    minimumObjectsScan_ = value;
  }
  inline int minimumGoodReducedCosts() const {
    return minimumGoodReducedCosts_;
  }
  inline void setMinimumGoodReducedCosts(int value) {
    minimumGoodReducedCosts_ = value;
  }
  inline double startFraction() const {
    return startFraction_;
  }
  inline void setStartFraction(double value) {
    startFraction_ = value;
  }
  inline double endFraction() const {
    return endFraction_;
  }
  inline void setEndFraction(double value) {
    endFraction_ = value;
  }
  inline double savedBestDj() const {
    return savedBestDj_;
  }
  inline void setSavedBestDj(double value) {
    savedBestDj_ = value;
  }
  inline int originalWanted() const {
    return originalWanted_;
  }
  inline void setOriginalWanted(int value) {
    originalWanted_ = value;
  }
  inline int currentWanted() const {
    return currentWanted_;
  }
  inline void setCurrentWanted(int value) {
    currentWanted_ = value;
  }
  inline int savedBestSequence() const {
    return savedBestSequence_;
  }
  inline void setSavedBestSequence(int value) {
    savedBestSequence_ = value;
  }
  inline int * startColumnBlock() const
  {return startColumnBlock_;}
  inline const int * blockStart() const
  { return blockStart_;}
  inline bool gotRowCopy() const
  { return rowStart_!=0;}
  inline int blockStart(int block) const
  { return blockStart_[block];}
  inline int numberColumnBlocks() const
  { return numberColumnBlocks_;}
  inline int numberRowBlocks() const
  { return numberRowBlocks_;}
  
  
  AbcMatrix();
  ~AbcMatrix();
  
  AbcMatrix(const AbcMatrix&);
  AbcMatrix(const CoinPackedMatrix&);
  AbcMatrix (const AbcMatrix & wholeModel,
             int numberRows, const int * whichRows,
             int numberColumns, const int * whichColumns);
  AbcMatrix (const CoinPackedMatrix & wholeModel,
             int numberRows, const int * whichRows,
             int numberColumns, const int * whichColumns);
  
  AbcMatrix& operator=(const AbcMatrix&);
  void copy(const AbcMatrix * from);
private:
  
protected:
  CoinPackedMatrix * matrix_;
  mutable AbcSimplex * model_;
#if ABC_PARALLEL==0
#define NUMBER_ROW_BLOCKS 1
#define NUMBER_COLUMN_BLOCKS 1
#elif ABC_PARALLEL==1
#define NUMBER_ROW_BLOCKS 4
#define NUMBER_COLUMN_BLOCKS 4
#else
#define NUMBER_ROW_BLOCKS 8
#define NUMBER_COLUMN_BLOCKS 8
#endif

  CoinBigIndex * rowStart_;
  double * element_;
  int * column_;
  mutable int startColumnBlock_[NUMBER_COLUMN_BLOCKS+1];
  int blockStart_[NUMBER_ROW_BLOCKS+1];
  mutable int numberColumnBlocks_;
  int numberRowBlocks_;
  //#define COUNT_COPY
#ifdef COUNT_COPY
#define MAX_COUNT 13
  CoinBigIndex countStart_[MAX_COUNT+1];
  int countFirst_[MAX_COUNT+1];
  // later int countEndUseful_[MAX_COUNT+1];
  int * countRealColumn_;
  // later int * countInverseRealColumn_;
  CoinBigIndex * countStartLarge_;
  int * countRow_;
  double * countElement_;
  int smallestCount_;
  int largestCount_;
#endif 
  //AbcMatrix2 * rowCopy_;
  //AbcMatrix3 * columnCopy_;
  double startFraction_;
  double endFraction_;
  double savedBestDj_;
  int originalWanted_;
  int currentWanted_;
  int savedBestSequence_;
  int minimumObjectsScan_;
  int minimumGoodReducedCosts_;
};
#ifdef THREAD
#include <pthread.h>
typedef struct {
  double acceptablePivot;
  const AbcSimplex * model;
  double * spare;
  int * spareIndex;
  double * arrayTemp;
  int * indexTemp;
  int * numberInPtr;
  double * bestPossiblePtr;
  double * upperThetaPtr;
  int * posFreePtr;
  double * freePivotPtr;
  int * numberOutPtr;
  const unsigned short * count;
  const double * pi;
  const CoinBigIndex * rowStart;
  const double * element;
  const unsigned short * column;
  int offset;
  int numberInRowArray;
  int numberLook;
} dualColumn0Struct;
#endif
class AbcMatrix2 {
  
public:
  void transposeTimes(const AbcSimplex * model,
                      const CoinPackedMatrix * rowCopy,
                      const CoinIndexedVector & x,
                      CoinIndexedVector & spareArray,
                      CoinIndexedVector & z) const;
  inline bool usefulInfo() const {
    return rowStart_ != NULL;
  }
  
  
  AbcMatrix2();
  AbcMatrix2(AbcSimplex * model, const CoinPackedMatrix * rowCopy);
  ~AbcMatrix2();
  
  AbcMatrix2(const AbcMatrix2&);
  AbcMatrix2& operator=(const AbcMatrix2&);
  
  
protected:
  int numberBlocks_;
  int numberRows_;
  int * offset_;
  mutable unsigned short * count_;
  mutable CoinBigIndex * rowStart_;
  unsigned short * column_;
  double * work_;
#ifdef THREAD
  pthread_t * threadId_;
  dualColumn0Struct * info_;
#endif

};
typedef struct {
  CoinBigIndex startElements_; // point to data
  int startIndices_; // point to column_
  int numberInBlock_;
  int numberPrice_; // at beginning
  int numberElements_; // number elements per column
} blockStruct3;
class AbcMatrix3 {
  
public:
  void transposeTimes(const AbcSimplex * model,
                      const double * pi,
                      CoinIndexedVector & output) const;
  void transposeTimes2(const AbcSimplex * model,
                       const double * pi, CoinIndexedVector & dj1,
                       const double * piWeight,
                       double referenceIn, double devex,
                       // Array for exact devex to say what is in reference framework
                       unsigned int * reference,
                       double * weights, double scaleFactor);
  
  
  AbcMatrix3();
  AbcMatrix3(AbcSimplex * model, const CoinPackedMatrix * columnCopy);
  ~AbcMatrix3();
  
  AbcMatrix3(const AbcMatrix3&);
  AbcMatrix3& operator=(const AbcMatrix3&);

  void sortBlocks(const AbcSimplex * model);
  void swapOne(const AbcSimplex * model, const AbcMatrix * matrix,
               int iColumn);
  
  
protected:
  int numberBlocks_;
  int numberColumns_;
  int * column_;
  CoinBigIndex * start_;
  int * row_;
  double * element_;
  blockStruct * block_;
};

#endif