AbcMatrix.hpp

Go to the documentation of this file.

/* $Id$ */
// 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/