ClpCholeskyBase.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef ClpCholeskyBase_H
#define ClpCholeskyBase_H
 
#include "CoinPragma.hpp"
#include "CoinTypes.hpp"
//#define CLP_LONG_CHOLESKY 0
#ifndef CLP_LONG_CHOLESKY
#define CLP_LONG_CHOLESKY 0
#endif
/* valid combinations are
   CLP_LONG_CHOLESKY 0 and COIN_LONG_WORK 0
   CLP_LONG_CHOLESKY 1 and COIN_LONG_WORK 1
   CLP_LONG_CHOLESKY 2 and COIN_LONG_WORK 1
*/
#if COIN_LONG_WORK == 0
#if CLP_LONG_CHOLESKY > 0
#define CHOLESKY_BAD_COMBINATION
#endif
#else
#if CLP_LONG_CHOLESKY == 0
#define CHOLESKY_BAD_COMBINATION
#endif
#endif
#ifdef CHOLESKY_BAD_COMBINATION
#warning("Bad combination of CLP_LONG_CHOLESKY and COIN_BIG_DOUBLE/COIN_LONG_WORK");
"Bad combination of CLP_LONG_CHOLESKY and COIN_LONG_WORK"
#endif
#if CLP_LONG_CHOLESKY > 1
  typedef long double longDouble;
#define CHOL_SMALL_VALUE 1.0e-15
#elif CLP_LONG_CHOLESKY == 1
typedef double longDouble;
#define CHOL_SMALL_VALUE 1.0e-11
#else
typedef double longDouble;
#define CHOL_SMALL_VALUE 1.0e-11
#endif
class ClpInterior;
class ClpCholeskyDense;
class ClpMatrixBase;
 
class ClpCholeskyBase {
 
public:
  virtual int order(ClpInterior *model);
  virtual int symbolic();
  virtual int factorize(const CoinWorkDouble *diagonal, int *rowsDropped);
  virtual void solve(CoinWorkDouble *region);
  virtual void solveKKT(CoinWorkDouble *region1, CoinWorkDouble *region2, const CoinWorkDouble *diagonal,
    CoinWorkDouble diagonalScaleFactor);
 
private:
  int orderAMD();
 
public:
 
  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 int 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:
  inline void setType(int type)
  {
    type_ = type;
  }
  inline void setModel(ClpInterior *model)
  {
    model_ = model;
  }
 
  int symbolic1(const int *Astart, const int *Arow);
  void symbolic2(const int *Astart, const int *Arow);
  void factorizePart2(int *rowsDropped);
  void solve(CoinWorkDouble *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_;
  int *choleskyStart_;
  int *choleskyRow_;
  int *indexStart_;
  longDouble *diagonal_;
  longDouble *workDouble_;
  int *link_;
  // Integer work array
  int *workInteger_;
  // Clique information
  int *clique_;
  int sizeFactor_;
  int sizeIndex_;
  int firstDense_;
  int integerParameters_[64];
  double doubleParameters_[64];
  ClpMatrixBase *rowCopy_;
  char *whichDense_;
  longDouble *denseColumn_;
  ClpCholeskyDense *dense_;
  int denseThreshold_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/