CoinDenseFactorization.hpp

Go to the documentation of this file.

/* $Id: CoinDenseFactorization.hpp 1759 2014-11-18 11:07:23Z forrest $ */
// Copyright (C) 2008, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).


/* 
   Authors
   
   John Forrest

 */
#ifndef CoinDenseFactorization_H
#define CoinDenseFactorization_H

#include <iostream>
#include <string>
#include <cassert>
#include "CoinTypes.hpp"
#include "CoinIndexedVector.hpp"
#include "CoinFactorization.hpp"
#if COIN_FACTORIZATION_DENSE_CODE == 2
#undef COIN_FACTORIZATION_DENSE_CODE
#endif
class CoinPackedMatrix;
class CoinOtherFactorization {

public:

  CoinOtherFactorization (  );
  CoinOtherFactorization ( const CoinOtherFactorization &other);
  
  virtual ~CoinOtherFactorization (  );
  CoinOtherFactorization & operator = ( const CoinOtherFactorization & other );
 
  virtual CoinOtherFactorization * clone() const = 0;

  inline int status (  ) const {
    return status_;
  }
  inline void setStatus (  int value)
  {  status_=value;  }
  inline int pivots (  ) const {
    return numberPivots_;
  }
  inline void setPivots (  int value ) 
  { numberPivots_=value; }
  inline void setNumberRows(int value)
  { numberRows_ = value; }
  inline int numberRows (  ) const {
    return numberRows_;
  }
  inline int numberColumns (  ) const {
    return numberColumns_;
  }
  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_ ;
  }
  virtual void maximumPivots (  int value );

  inline double pivotTolerance (  ) const {
    return pivotTolerance_ ;
  }
  void pivotTolerance (  double value );
  inline double zeroTolerance (  ) const {
    return zeroTolerance_ ;
  }
  void zeroTolerance (  double value );
#ifndef COIN_FAST_CODE
  inline double slackValue (  ) const {
    return slackValue_ ;
  }
  void slackValue (  double value );
#endif
  virtual CoinFactorizationDouble * elements() const;
  virtual int * pivotRow() const;
  virtual CoinFactorizationDouble * workArea() const;
  virtual int * intWorkArea() const;
  virtual int * numberInRow() const;
  virtual int * numberInColumn() const;
  virtual CoinBigIndex * starts() const;
  virtual int * permuteBack() const;
  inline int solveMode() const
  { return solveMode_ ;}
  inline void setSolveMode(int value)
  { solveMode_ = value;}
  virtual bool wantsTableauColumn() const;
  virtual void setUsefulInformation(const int * info,int whereFrom);
  virtual void clearArrays() {}

  virtual int * indices() const  = 0;
  virtual int * permute() const = 0;
  virtual int numberElements (  ) const = 0;

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


  virtual int replaceColumn ( CoinIndexedVector * regionSparse,
                      int pivotRow,
                      double pivotCheck ,
                              bool checkBeforeModifying=false,
                              double acceptablePivot=1.0e-8)=0;

  virtual int updateColumnFT ( CoinIndexedVector * regionSparse,
                               CoinIndexedVector * regionSparse2,
                               bool noPermute=false) = 0;
  virtual int updateColumn ( CoinIndexedVector * regionSparse,
                     CoinIndexedVector * regionSparse2,
                     bool noPermute=false) const = 0;
    virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1,
                           CoinIndexedVector * regionSparse2,
                           CoinIndexedVector * regionSparse3,
                           bool noPermute=false) = 0;
  virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse,
                              CoinIndexedVector * regionSparse2) const = 0;

protected:

  double pivotTolerance_;
  double zeroTolerance_;
#ifndef COIN_FAST_CODE
  double slackValue_;
#else
#ifndef slackValue_
#define slackValue_ -1.0
#endif
#endif
  double relaxCheck_;
  CoinBigIndex factorElements_;
  int numberRows_;
  int numberColumns_;
  int numberGoodU_;
  int maximumPivots_;
  int numberPivots_;
  int status_;
  int maximumRows_;
  CoinBigIndex maximumSpace_;
  int * pivotRow_;
  CoinFactorizationDouble * elements_;
  CoinFactorizationDouble * workArea_;
  int solveMode_;
};
class CoinDenseFactorization : public CoinOtherFactorization {
   friend void CoinDenseFactorizationUnitTest( const std::string & mpsDir );

public:

  CoinDenseFactorization (  );
  CoinDenseFactorization ( const CoinDenseFactorization &other);
  
  virtual ~CoinDenseFactorization (  );
  CoinDenseFactorization & operator = ( const CoinDenseFactorization & other );
  virtual CoinOtherFactorization * clone() const ;

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

  virtual inline int numberElements (  ) const {
    return numberRows_*(numberColumns_+numberPivots_);
  }
  double maximumCoefficient() const;


  virtual int replaceColumn ( CoinIndexedVector * regionSparse,
                      int pivotRow,
                      double pivotCheck ,
                              bool checkBeforeModifying=false,
                              double acceptablePivot=1.0e-8);

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

  inline void clearArrays()
  { gutsOfDestructor();}
  virtual inline int * indices() const
  { return reinterpret_cast<int *> (elements_+numberRows_*numberRows_);}
  virtual inline int * permute() const
  { return NULL;/*pivotRow_*/;}

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

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


};
#endif