ClpCholeskyBase.hpp

Go to the documentation of this file.

/* $Id: ClpCholeskyBase.hpp 1722 2011-04-17 09:58:37Z stefan $ */
// 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 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:
     inline void setType(int type) {
          type_ = type;
     }
     inline void setModel(ClpInterior * model) {
          model_ = model;
     }

     int symbolic1(const CoinBigIndex * Astart, const int * Arow);
     void symbolic2(const CoinBigIndex * 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_;
     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