/home/coin/SVN-release/CoinAll-1.1.0/CoinUtils/src/CoinDenseFactorization.hpp

Go to the documentation of this file.

// Copyright (C) 2008, International Business Machines
// Corporation and others.  All Rights Reserved.

/* 
   Authors
   
   John Forrest

 */
#ifndef CoinDenseFactorization_H
#define CoinDenseFactorization_H

#include <iostream>
#include <string>
#include <cassert>
#include "CoinFinite.hpp"
#include "CoinIndexedVector.hpp"
class CoinPackedMatrix;
class CoinDenseFactorization {
   friend void CoinDenseFactorizationUnitTest( const std::string & mpsDir );

public:


  CoinDenseFactorization (  );
  CoinDenseFactorization ( const CoinDenseFactorization &other);
  
  ~CoinDenseFactorization (  );
  CoinDenseFactorization & operator = ( const CoinDenseFactorization & other );


  void getAreas ( int numberRows,
                  int numberColumns,
                  CoinBigIndex maximumL,
                  CoinBigIndex maximumU );
  
  void preProcess ( );
  int factor ( );
  void postProcess(const int * sequence, int * pivotVariable);
  void makeNonSingular(int * sequence, int numberColumns);


  inline int status (  ) const {
    return status_;
  }
  inline void setStatus (  int value)
  {  status_=value;  }
  inline int pivots (  ) const {
    return numberPivots_;
  }
  inline int numberRows (  ) const {
    return numberRows_;
  }
  inline int numberColumns (  ) const {
    return numberColumns_;
  }
  inline int numberElements (  ) const {
    return numberRows_*(numberColumns_+numberPivots_);
  }
  inline int numberGoodColumns (  ) const {
    return numberGoodU_;
  }
  inline void relaxAccuracyCheck(double value)
  { relaxCheck_ = value;}
  inline double getAccuracyCheck() const
  { return relaxCheck_;}
  inline int maximumPivots (  ) const {
    return maximumPivots_ ;
  }
  void maximumPivots (  int value );

  inline double pivotTolerance (  ) const {
    return pivotTolerance_ ;
  }
  void pivotTolerance (  double value );
  inline double zeroTolerance (  ) const {
    return zeroTolerance_ ;
  }
  inline void zeroTolerance (  double value )
  { zeroTolerance_ = value;}
  inline double slackValue (  ) const {
    return slackValue_ ;
  }
  void slackValue (  double value );
  double maximumCoefficient() const;


  int replaceColumn ( CoinIndexedVector * regionSparse,
                      int pivotRow,
                      double pivotCheck ,
                      bool checkBeforeModifying=false);

  inline int updateColumnFT ( CoinIndexedVector * regionSparse,
                       CoinIndexedVector * regionSparse2)
  { return updateColumn(regionSparse,regionSparse2);}
  int updateColumn ( CoinIndexedVector * regionSparse,
                     CoinIndexedVector * regionSparse2,
                     bool noPermute=false) const;
  int updateColumnTranspose ( CoinIndexedVector * regionSparse,
                              CoinIndexedVector * regionSparse2) const;



  inline void clearArrays()
  { gutsOfDestructor();}
  inline double * elements() const
  { return elements_;}
  inline int * indices() const
  { return (int *) (elements_+numberRows_*numberRows_);}
  inline CoinBigIndex * starts() const
  { return (CoinBigIndex *) pivotRow_;}
  inline int * pivotRow() const
  { return pivotRow_;}
  inline int * permute() const
  { return pivotRow_;}
  inline int * permuteBack() const
  { return pivotRow_+numberRows_;}
  inline double * workArea() const
  { return workArea_;}
  inline int * intWorkArea() const
  { return (int *) workArea_;}

  void gutsOfDestructor();
  void gutsOfInitialize();
  void gutsOfCopy(const CoinDenseFactorization &other);

protected:
  int checkPivot(double saveFromU, double oldPivot) const;
protected:


  double pivotTolerance_;
  double zeroTolerance_;
  double slackValue_;
  double relaxCheck_;
  int numberRows_;
  int numberColumns_;
  int maximumRows_;
  CoinBigIndex maximumSpace_;
  int numberGoodU_;
  int maximumPivots_;
  int numberPivots_;
  CoinBigIndex factorElements_;
  int * pivotRow_;
  int status_;
  double * elements_;
  double * workArea_;
};
#endif

---