CoinOslFactorization.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 1987, 2009, 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 CoinOslFactorization_H
#define CoinOslFactorization_H
#include <iostream>
#include <string>
#include <cassert>
#include "CoinTypes.hpp"
#include "CoinIndexedVector.hpp"
#include "CoinDenseFactorization.hpp"
class CoinPackedMatrix;
typedef struct {
  int suc, pre;
} EKKHlink;
typedef struct _EKKfactinfo {
  double drtpiv;
  double demark;
  double zpivlu;
  double zeroTolerance;
  double areaFactor;
  int *xrsadr;
  int *xcsadr;
  int *xrnadr;
  int *xcnadr;
  int *krpadr;
  int *kcpadr;
  int *mpermu;
  int *bitArray;
  int *back;
  char *nonzero;
  double *trueStart;
  mutable double *kadrpm;
  int *R_etas_index;
  int *R_etas_start;
  double *R_etas_element;
 
  int *xecadr;
  int *xeradr;
  double *xeeadr;
  double *xe2adr;
  EKKHlink *kp1adr;
  EKKHlink *kp2adr;
  double *kw1adr;
  double *kw2adr;
  double *kw3adr;
  int *hpivcoR;
  int nrow;
  int nrowmx;
  int firstDoRow;
  int firstLRow;
  int maxinv;
  int nnetas;
  int iterin;
  int iter0;
  int invok;
  int nbfinv;
  int num_resets;
  int nnentl;
  int nnentu;
#ifdef CLP_REUSE_ETAS
  int save_nnentu;
#endif
  int ndenuc;
  int npivots; /* use as xpivsq in factorization */
  int kmxeta;
  int xnetal;
  int first_dense;
  int last_dense;
  int iterno;
  int numberSlacks;
  int lastSlack;
  int firstNonSlack;
  int xnetalval;
  int lstart;
  int if_sparse_update;
  mutable int packedMode;
  int switch_off_sparse_update;
  int nuspike;
  bool rows_ok; /* replaces test using mrstrt[1] */
#ifdef CLP_REUSE_ETAS
  mutable int reintro;
#endif
  int nR_etas;
  int sortedEta; /* if vector for F-T is sorted */
  int lastEtaCount;
  int ifvsol;
  int eta_size;
  int last_eta_size;
  int maxNNetas;
} EKKfactinfo;
 
class CoinOslFactorization : public CoinOtherFactorization {
  friend void CoinOslFactorizationUnitTest(const std::string &mpsDir);
 
public:
  CoinOslFactorization();
  CoinOslFactorization(const CoinOslFactorization &other);
 
  virtual ~CoinOslFactorization();
  CoinOslFactorization &operator=(const CoinOslFactorization &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);
  int factorize(const CoinPackedMatrix &matrix,
    int rowIsBasic[], int columnIsBasic[],
    double areaFactor = 0.0);
 
  virtual inline int numberElements() const
  {
    return numberRows_ * (numberColumns_ + numberPivots_);
  }
  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;
  virtual bool wantsTableauColumn() const;
  virtual void setUsefulInformation(const int *info, int whereFrom);
  virtual void maximumPivots(int value);
 
  double maximumCoefficient() const;
  double conditionNumber() const;
  virtual void clearArrays();
 
 
  virtual int replaceColumn(CoinIndexedVector *regionSparse,
    int pivotRow,
    double pivotCheck,
    bool checkBeforeModifying = false,
    double acceptablePivot = 1.0e-8);
 
  virtual int updateColumnFT(CoinIndexedVector *regionSparse,
    CoinIndexedVector *regionSparse2,
    bool noPermute = false);
  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 int *indices() const;
  virtual inline int *permute() const
  {
    return NULL; /*pivotRow_*/
    ;
  }
 
  void gutsOfDestructor(bool clearFact = true);
  void gutsOfInitialize(bool zapFact = true);
  void gutsOfCopy(const CoinOslFactorization &other);
 
protected:
  int checkPivot(double saveFromU, double oldPivot) const;
protected:
  EKKfactinfo factInfo_;
};
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/