CoinDenseFactorization.hpp

Go to the documentation of this file.

/* $Id: CoinDenseFactorization.hpp 2083 2019-01-06 19:38:09Z unxusr $ */
// 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 int *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,
    int maximumL,
    int 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_;
  int factorElements_;
  int numberRows_;
  int numberColumns_;
  int numberGoodU_;
  int maximumPivots_;
  int numberPivots_;
  int status_;
  int maximumRows_;
  int 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,
    int maximumL,
    int 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

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/