/home/coin/SVN-release/CoinAll-1.1.0/Clp/src/ClpCholeskyBase.hpp

Go to the documentation of this file.

// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef ClpCholeskyBase_H
#define ClpCholeskyBase_H

#include "CoinPragma.hpp"
#include "CoinFinite.hpp"
#define CLP_LONG_CHOLESKY 0
#if CLP_LONG_CHOLESKY>1
typedef long double longDouble;
typedef long double longWork;
#elif CLP_LONG_CHOLESKY==1
typedef double longDouble;
typedef long double longWork;
#else
typedef double longDouble;
typedef double longWork;
#endif
class ClpInterior;
class ClpCholeskyDense;
class ClpMatrixBase;

class ClpCholeskyBase  {
  
public:
  virtual int order(ClpInterior * model);
  virtual int symbolic();
  virtual int factorize(const double * diagonal, int * rowsDropped) ;
  virtual void solve (double * region) ;
  virtual void solveKKT (double * region1, double * region2, const double * diagonal,
                         double diagonalScaleFactor);


  inline int status() const 
  {return status_;}
  inline int numberRowsDropped() const 
  {return numberRowsDropped_;}
  void resetRowsDropped();
  inline char * rowsDropped() const 
  {return rowsDropped_;}
  inline double choleskyCondition() const 
  {return choleskyCondition_;}
  inline double goDense() const 
  {return goDense_;}
  inline void setGoDense(double value)
  {goDense_=value;}
  inline int rank() const 
  {return numberRows_-numberRowsDropped_;}
  inline int numberRows() const 
  {return numberRows_;}
  inline CoinBigIndex size() const
  { return sizeFactor_;}
  inline longDouble * sparseFactor() const
  { return sparseFactor_;}
  inline longDouble * diagonal() const
  { return diagonal_;}
  inline longDouble * workDouble() const
  { return workDouble_;}
  inline bool kkt() const
  { return doKKT_;}
  inline void setKKT(bool yesNo)
  { doKKT_ = yesNo;}
  inline void setIntegerParameter(int i,int value)
  { integerParameters_[i]=value;}
  inline int getIntegerParameter(int i)
  { return integerParameters_[i];}
  inline void setDoubleParameter(int i,double value)
  { doubleParameters_[i]=value;}
  inline double getDoubleParameter(int i)
  { return doubleParameters_[i];}
  
  
public:

  ClpCholeskyBase(int denseThreshold=-1);
   virtual ~ClpCholeskyBase();
   ClpCholeskyBase(const ClpCholeskyBase&);
   ClpCholeskyBase& operator=(const ClpCholeskyBase&);



  virtual ClpCholeskyBase * clone() const;
 
  inline int type() const
  { if (doKKT_) return 100; else return type_;}
protected:
  void setType(int type) {type_=type;}
   
  int symbolic1(const CoinBigIndex * Astart, const int * Arow);
  void symbolic2(const CoinBigIndex * Astart, const int * Arow);
  void factorizePart2(int * rowsDropped) ;
  void solve(double * region, int type);
  void solveLong(longDouble * region, int type);
  int preOrder(bool lowerTriangular, bool includeDiagonal, bool doKKT);
  void updateDense(longDouble * d, longDouble * work, int * first);
    
protected:

  int type_;
  bool doKKT_;
  double goDense_;
  double choleskyCondition_;
  ClpInterior * model_;
  int numberTrials_;
  int numberRows_;
  int status_;
  char * rowsDropped_;
  int * permuteInverse_;
  int * permute_;
  int numberRowsDropped_;
  longDouble * sparseFactor_;
  CoinBigIndex * choleskyStart_;
  int * choleskyRow_;
  CoinBigIndex * indexStart_;
  longDouble * diagonal_;
  longDouble * workDouble_;
  int * link_;
  // Integer work array
  CoinBigIndex * workInteger_;
  // Clique information
  int * clique_;
  CoinBigIndex sizeFactor_;
  CoinBigIndex sizeIndex_;
  int firstDense_;
  int integerParameters_[64];
  double doubleParameters_[64];
  ClpMatrixBase * rowCopy_;
  char * whichDense_;
  longDouble * denseColumn_;
  ClpCholeskyDense * dense_;
  int denseThreshold_;
};

#endif

---