CoinOslFactorization.hpp

Go to the documentation of this file.

/* $Id: CoinOslFactorization.hpp 1416 2011-04-17 09:57:29Z stefan $ */
// 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,
                  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);
  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 CoinBigIndex * 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