AbcSimplex.hpp

Go to the documentation of this file.

/* $Id: AbcSimplex.hpp 2070 2014-11-18 11:12:54Z forrest $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others, Copyright (C) 2012, FasterCoin.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
/*
  Authors
  
  John Forrest
  
*/
#ifndef AbcSimplex_H
#define AbcSimplex_H

#include <iostream>
#include <cfloat>
#include "ClpModel.hpp"
#include "ClpMatrixBase.hpp"
#include "CoinIndexedVector.hpp"
#include "AbcCommon.hpp"
class AbcSimplex;
#include "ClpSolve.hpp"
#include "CoinAbcCommon.hpp"
#include "ClpSimplex.hpp"
class AbcDualRowPivot;
class AbcPrimalColumnPivot;
class AbcSimplexFactorization;
class AbcNonLinearCost;
class OsiAbcSolverInterface;
class CoinWarmStartBasis;
class ClpDisasterHandler;
class AbcSimplexProgress;
class AbcMatrix;
class AbcTolerancesEtc;

#define PAN
#if ABC_NORMAL_DEBUG>0
#define PRINT_PAN 1
#endif
#define TRY_ABC_GUS
#define HEAVY_PERTURBATION 57
#if ABC_PARALLEL==1
// Use pthreads
#include <pthread.h>
#endif
class AbcSimplex : public ClpSimplex {
  friend void AbcSimplexUnitTest(const std::string & mpsDir);
  
public:
  enum Status {
    atLowerBound = 0x00, // so we can use bottom two bits to sort and swap signs
    atUpperBound = 0x01,
    isFree = 0x04,
    superBasic = 0x05,
    basic = 0x06,
    isFixed = 0x07
  };
  // For Dual
  enum FakeBound {
    noFake = 0x00,
    lowerFake = 0x01,
    upperFake = 0x02,
    bothFake = 0x03
  };
  
  AbcSimplex (bool emptyMessages = false  );
  
  AbcSimplex(const AbcSimplex & rhs);
  AbcSimplex(const ClpSimplex & rhs);
  AbcSimplex (const ClpSimplex * wholeModel,
              int numberRows, const int * whichRows,
              int numberColumns, const int * whichColumns,
              bool dropNames = true, bool dropIntegers = true,
              bool fixOthers = false);
  AbcSimplex (const AbcSimplex * wholeModel,
              int numberRows, const int * whichRows,
              int numberColumns, const int * whichColumns,
              bool dropNames = true, bool dropIntegers = true,
              bool fixOthers = false);
  AbcSimplex (AbcSimplex * wholeModel,
              int numberColumns, const int * whichColumns);
  void originalModel(AbcSimplex * miniModel);
  AbcSimplex (const ClpSimplex * clpSimplex);
  void putBackSolution(ClpSimplex * simplex);
  //void setPersistenceFlag(int value);
  void makeBaseModel();
  void deleteBaseModel();
  inline AbcSimplex *  baseModel() const {
    return abcBaseModel_;
  }
  void setToBaseModel(AbcSimplex * model = NULL);
  AbcSimplex & operator=(const AbcSimplex & rhs);
  ~AbcSimplex (  );
  
  int dual();
  int doAbcDual();
  int primal(int ifValuesPass);
  int doAbcPrimal(int ifValuesPass);
  CoinWarmStartBasis * getBasis() const;
  void setFactorization( AbcSimplexFactorization & factorization);
  AbcSimplexFactorization * swapFactorization( AbcSimplexFactorization * factorization);
  AbcSimplexFactorization * getEmptyFactorization();
  int tightenPrimalBounds();
  void setDualRowPivotAlgorithm(AbcDualRowPivot & choice);
  void setPrimalColumnPivotAlgorithm(AbcPrimalColumnPivot & choice);
  void defaultFactorizationFrequency();
  
  inline AbcSimplexFactorization * factorization() const {
    return reinterpret_cast<AbcSimplexFactorization *>(abcFactorization_);
  }
#ifdef EARLY_FACTORIZE
  inline AbcSimplexFactorization * earlyFactorization() const {
    return reinterpret_cast<AbcSimplexFactorization *>(abcEarlyFactorization_);
  }
#endif
  int factorizationFrequency() const;
  void setFactorizationFrequency(int value);
  inline int maximumAbcNumberRows() const
  { return maximumAbcNumberRows_;}
  inline int maximumNumberTotal() const
  { return maximumNumberTotal_;}
  inline int maximumTotal() const
  { return maximumNumberTotal_;}
  bool isObjectiveLimitTestValid() const ;
  inline int numberTotal() const
  { return numberTotal_;}
  inline int numberTotalWithoutFixed() const
  { return numberTotalWithoutFixed_;}
  inline CoinPartitionedVector * usefulArray(int index) {
    return & usefulArray_[index];
  }
  inline CoinPartitionedVector * usefulArray(int index) const {
    return const_cast<CoinPartitionedVector *>(&usefulArray_[index]);
  }
  
  /******************** End of most useful part **************/
  int getSolution ();
  void setClpSimplexObjectiveValue();
  void setupDualValuesPass(const double * fakeDuals,
                           const double * fakePrimals,
                           int type);
  inline double minimizationObjectiveValue() const
  { return objectiveValue_-dblParam_[ClpObjOffset];}
  inline double currentDualTolerance() const
  { return currentDualTolerance_;}
  inline void setCurrentDualTolerance(double value) {
    currentDualTolerance_ = value;
  }
  inline AbcNonLinearCost * abcNonLinearCost() const {
    return abcNonLinearCost_;
  }
  double * perturbationSaved() const
  { return perturbationSaved_;}
  inline double acceptablePivot() const
  { return acceptablePivot_;}
  inline int ordinaryVariables() const
  { return ordinaryVariables_;}
  inline int numberOrdinary() const
  { return numberOrdinary_;}
  inline void setNumberOrdinary(int number)
  { numberOrdinary_=number;}
  inline double currentDualBound() const
  { return currentDualBound_;}
  inline AbcDualRowPivot * dualRowPivot() const {
    return abcDualRowPivot_;
  }
  inline AbcPrimalColumnPivot * primalColumnPivot() const {
    return abcPrimalColumnPivot_;
  }
  inline AbcMatrix * abcMatrix() const     {
    return abcMatrix_;
  }
  int internalFactorize(int solveType);
  void permuteIn();
  void permuteBasis();
  void permuteOut(int whatsWanted);
  ClpDataSave saveData() ;
  void restoreData(ClpDataSave saved);
  void cleanStatus(bool valuesPass=false);
  int computeDuals(double * givenDjs, CoinIndexedVector * array1, CoinIndexedVector * array2);
  int computePrimals (CoinIndexedVector * array1, CoinIndexedVector * array2);
  void computeObjective ();
  void setMultipleSequenceIn(int sequenceIn[4]);
  inline void unpack(CoinIndexedVector & rowArray) const 
  {unpack(rowArray,sequenceIn_);}
  void unpack(CoinIndexedVector & rowArray, int sequence) const;
  int housekeeping(/*double objectiveChange*/);
  void checkPrimalSolution(bool justBasic);
  void checkDualSolution();
  void checkDualSolutionPlusFake();
  void checkBothSolutions();
  int gutsOfSolution(int type);
  int gutsOfPrimalSolution(int type);
  void saveGoodStatus();
  void restoreGoodStatus(int type);
#define rowUseScale_ scaleFromExternal_
#define inverseRowUseScale_ scaleToExternal_
  void refreshCosts();
  void refreshLower(unsigned int type=~(ROW_LOWER_SAME|COLUMN_UPPER_SAME));
  void refreshUpper(unsigned int type=~(ROW_LOWER_SAME|COLUMN_LOWER_SAME));
  void setupPointers(int maxRows,int maxColumns);
  void copyFromSaved(int type=31);
  void fillPerturbation(int start, int number);
  void checkArrays(int ignoreEmpty=0) const;
  void checkDjs(int type=1) const;
  void checkSolutionBasic() const;
  void checkMoveBack(bool checkDuals);
public:
  void setValuesPassAction(double incomingInfeasibility,
                           double allowedInfeasibility);
  int cleanFactorization(int ifValuesPass);
  void moveStatusToClp(ClpSimplex * clpModel);
  void moveStatusFromClp(ClpSimplex * clpModel);

public:

  inline double clpObjectiveValue() const {
  return (objectiveValue_+objectiveOffset_-bestPossibleImprovement_)*optimizationDirection_ - dblParam_[ClpObjOffset];
  }
  inline int * pivotVariable() const {
    return abcPivotVariable_;
  }
  inline int stateOfProblem() const
  { return stateOfProblem_;}
  inline void setStateOfProblem(int value)
  { stateOfProblem_=value;}
  //inline int * fromExternal() const
  //{ return fromExternal_;}
  //inline int * toExternal() const
  //{return toExternal_;}
  inline double * scaleFromExternal() const
  {return scaleFromExternal_;}
  inline double * scaleToExternal() const
  {return scaleToExternal_;}
  inline double * rowScale2() const
  {return rowUseScale_;}
  inline double * inverseRowScale2() const
  {return inverseRowUseScale_;}
  inline double * inverseColumnScale2() const
  {return inverseColumnUseScale_;}
  inline double * columnScale2() const
  {return columnUseScale_;}
  inline int arrayForDualColumn() const
  {return arrayForDualColumn_;}
  inline double upperTheta() const
  {return upperTheta_;}
  inline int arrayForReplaceColumn() const
  { return arrayForReplaceColumn_;}
  inline int arrayForFlipBounds() const
  { return arrayForFlipBounds_;}
  inline int arrayForFlipRhs() const
  { return arrayForFlipRhs_;}
  inline int arrayForBtran() const
  { return arrayForBtran_;}
  inline int arrayForFtran() const
  { return arrayForFtran_;}
  inline int arrayForTableauRow() const
  { return arrayForTableauRow_;}
  double valueIncomingDual() const;
  const double * getColSolution() const; 
  
  const double * getRowPrice() const;
  
  const double * getReducedCost() const; 
  
  const double * getRowActivity() const; 
  
  int gutsOfSolution ( double * givenDuals,
                       const double * givenPrimals,
                       bool valuesPass = false);
  void gutsOfDelete(int type);
  void gutsOfCopy(const AbcSimplex & rhs);
  void gutsOfInitialize(int numberRows,int numberColumns,bool doMore);
  void gutsOfResize(int numberRows,int numberColumns);
  void translate(int type);
  void moveToBasic(int which=15);
public:
  inline double * solutionRegion() const {
    return abcSolution_;
  }
  inline double * djRegion() const {
    return abcDj_;
  }
  inline double * lowerRegion() const {
    return abcLower_;
  }
  inline double * upperRegion() const {
    return abcUpper_;
  }
  inline double * costRegion() const {
    return abcCost_;
  }
  inline double * solutionRegion(int which) const {
    return abcSolution_+which*maximumAbcNumberRows_;
  }
  inline double * djRegion(int which) const {
    return abcDj_+which*maximumAbcNumberRows_;
  }
  inline double * lowerRegion(int which) const {
    return abcLower_+which*maximumAbcNumberRows_;
  }
  inline double * upperRegion(int which) const {
    return abcUpper_+which*maximumAbcNumberRows_;
  }
  inline double * costRegion(int which) const {
    return abcCost_+which*maximumAbcNumberRows_;
  }
  inline double * solutionBasic() const {
    return solutionBasic_;
  }
  inline double * djBasic() const {
    return djBasic_;
  }
  inline double * lowerBasic() const {
    return lowerBasic_;
  }
  inline double * upperBasic() const {
    return upperBasic_;
  }
  inline double * costBasic() const {
    return costBasic_;
  }
  inline double * abcPerturbation() const
  { return abcPerturbation_;}
  inline double * fakeDjs() const
  { return djSaved_;}
  inline unsigned char * internalStatus() const 
  { return internalStatus_;}
  inline AbcSimplex::Status getInternalStatus(int sequence) const {
    return static_cast<Status> (internalStatus_[sequence] & 7);
  }
  inline AbcSimplex::Status getInternalColumnStatus(int sequence) const {
    return static_cast<Status> (internalStatus_[sequence+maximumAbcNumberRows_] & 7);
  }
  inline void setInternalStatus(int sequence, AbcSimplex::Status newstatus) {
    unsigned char & st_byte = internalStatus_[sequence];
    st_byte = static_cast<unsigned char>(st_byte & ~7);
    st_byte = static_cast<unsigned char>(st_byte | newstatus);
  }
  inline void setInternalColumnStatus(int sequence, AbcSimplex::Status newstatus) {
    unsigned char & st_byte = internalStatus_[sequence+maximumAbcNumberRows_];
    st_byte = static_cast<unsigned char>(st_byte & ~7);
    st_byte = static_cast<unsigned char>(st_byte | newstatus);
  }
  void setInitialDenseFactorization(bool onOff);
  bool  initialDenseFactorization() const;
  inline int sequenceIn() const {
    return sequenceIn_;
  }
  inline int sequenceOut() const {
    return sequenceOut_;
  }
  inline void  setSequenceIn(int sequence) {
    sequenceIn_ = sequence;
  }
  inline void  setSequenceOut(int sequence) {
    sequenceOut_ = sequence;
  }
#if 0

  inline int sequenceInternalIn() const {
    return sequenceInternalIn_;
  }
  inline int sequenceInternalOut() const {
    return sequenceInternalOut_;
  }
  inline void  setSequenceInternalIn(int sequence) {
    sequenceInternalIn_ = sequence;
  }
  inline void  setSequenceInternalOut(int sequence) {
    sequenceInternalOut_ = sequence;
  }
#endif
  inline int isColumn(int sequence) const {
    return sequence >= maximumAbcNumberRows_ ? 1 : 0;
  }
  inline int sequenceWithin(int sequence) const {
    return sequence < maximumAbcNumberRows_ ? sequence : sequence - maximumAbcNumberRows_;
  }
  inline int lastPivotRow() const
  { return lastPivotRow_;}
  inline int firstFree() const
  { return firstFree_;}
  inline int lastFirstFree() const
  { return lastFirstFree_;}
  inline int freeSequenceIn() const
  { return freeSequenceIn_;}
  inline double currentAcceptablePivot() const
  { return currentAcceptablePivot_;}
#ifdef PAN

  inline int fakeSuperBasic(int iSequence) {
    if ((internalStatus_[iSequence]&7)==4)
      return 0; // free
    if ((internalStatus_[iSequence]&7)!=5)
      return -2;
    double value=abcSolution_[iSequence];
    if (value<abcLower_[iSequence]+primalTolerance_) {
      if(abcDj_[iSequence]>=-currentDualTolerance_) {
        setInternalStatus(iSequence,atLowerBound);
#if PRINT_PAN>1 
        printf("Pansetting %d to lb\n",iSequence);
#endif
        return -1;
      } else {
        return 1;
      }
    } else if (value>abcUpper_[iSequence]-primalTolerance_) {
      if (abcDj_[iSequence]<=currentDualTolerance_) {
        setInternalStatus(iSequence,atUpperBound);
#if PRINT_PAN>1 
        printf("Pansetting %d to ub\n",iSequence);
#endif
        return -1;
      } else {
        return 1;
      }
    } else {
      return 0;
    }
  }
#endif
  inline double solution(int sequence) {
    return abcSolution_[sequence];
  }
  inline double & solutionAddress(int sequence) {
    return abcSolution_[sequence];
  }
  inline double reducedCost(int sequence) {
    return abcDj_[sequence];
  }
  inline double & reducedCostAddress(int sequence) {
    return abcDj_[sequence];
  }
  inline double lower(int sequence) {
    return abcLower_[sequence];
  }
  inline double & lowerAddress(int sequence) {
    return abcLower_[sequence];
  }
  inline double upper(int sequence) {
    return abcUpper_[sequence];
  }
  inline double & upperAddress(int sequence) {
    return abcUpper_[sequence];
  }
  inline double cost(int sequence) {
    return abcCost_[sequence];
  }
  inline double & costAddress(int sequence) {
    return abcCost_[sequence];
  }
  inline double originalLower(int iSequence) const {
    if (iSequence < numberColumns_) return columnLower_[iSequence];
    else
      return rowLower_[iSequence-numberColumns_];
  }
  inline double originalUpper(int iSequence) const {
    if (iSequence < numberColumns_) return columnUpper_[iSequence];
    else
      return rowUpper_[iSequence-numberColumns_];
  }
  inline AbcSimplexProgress * abcProgress()
  { return &abcProgress_;}
#ifdef ABC_SPRINT
  AbcSimplex * createSubProblem(int numberColumns,const int * whichColumn);
  void restoreFromSubProblem(AbcSimplex * fullProblem, const int * whichColumn);
#endif
public:
  inline void clearArraysPublic(int which)
  { clearArrays(which);}
  inline int getAvailableArrayPublic() const
  { return getAvailableArray();}
#if ABC_PARALLEL
  inline int parallelMode() const
  { return parallelMode_;}
  inline void setParallelMode(int value)
  { parallelMode_=value;}
  inline int numberCpus() const
  { return parallelMode_+1;}
#if ABC_PARALLEL==1
  inline void setStopStart(int value)
  { stopStart_=value;}
#endif
#endif
  //protected:
  void clearArrays(int which);
  void clearArrays(CoinPartitionedVector * which);
  int getAvailableArray() const;
  inline void setUsedArray(int which) const 
  {int check=1<<which;assert ((stateOfProblem_&check)==0);stateOfProblem_|=check;}
  inline void setAvailableArray(int which) const
  {int check=1<<which;assert ((stateOfProblem_&check)!=0);
    assert (!usefulArray_[which].getNumElements());stateOfProblem_&=~check;}
  void swapPrimalStuff();
  void swapDualStuff(int lastSequenceOut,int lastDirectionOut);
protected:

  void swap(int pivotRow,int nonBasicPosition,Status newStatus);
  inline void setFakeBound(int sequence, FakeBound fakeBound) {
    unsigned char & st_byte = internalStatus_[sequence];
    st_byte = static_cast<unsigned char>(st_byte & ~24);
    st_byte = static_cast<unsigned char>(st_byte | (fakeBound << 3));
  }
  inline FakeBound getFakeBound(int sequence) const {
    return static_cast<FakeBound> ((internalStatus_[sequence] >> 3) & 3);
  }
  bool atFakeBound(int sequence) const;
  inline void setPivoted( int sequence) {
    internalStatus_[sequence] = static_cast<unsigned char>(internalStatus_[sequence] | 32);
  }
  inline void clearPivoted( int sequence) {
    internalStatus_[sequence] = static_cast<unsigned char>(internalStatus_[sequence] & ~32);
  }
  inline bool pivoted(int sequence) const {
    return (((internalStatus_[sequence] >> 5) & 1) != 0);
  }
public:
  void swap(int pivotRow,int nonBasicPosition);
  void setFlagged( int sequence);
  inline void clearFlagged( int sequence) {
    internalStatus_[sequence] = static_cast<unsigned char>(internalStatus_[sequence] & ~64);
  }
  inline bool flagged(int sequence) const {
    return ((internalStatus_[sequence] & 64) != 0);
  }
protected:
  inline void setActive( int iRow) {
    internalStatus_[iRow] = static_cast<unsigned char>(internalStatus_[iRow] | 128);
  }
  inline void clearActive( int iRow) {
    internalStatus_[iRow] = static_cast<unsigned char>(internalStatus_[iRow] & ~128);
  }
  inline bool active(int iRow) const {
    return ((internalStatus_[iRow] & 128) != 0);
  }
public:
  void createStatus() ;
  void crash(int type);
  void putStuffInBasis(int type);
  void allSlackBasis();
  void checkConsistentPivots() const;
  void printStuff() const;
  int startup(int ifValuesPass);
  
  inline double rawObjectiveValue() const {
    return objectiveValue_;
  }
  void computeObjectiveValue(bool useWorkingSolution = false);
  double computeInternalObjectiveValue();
  void moveInfo(const AbcSimplex & rhs, bool justStatus = false);
#ifndef NUMBER_THREADS 
#define NUMBER_THREADS 3
#endif
#if ABC_PARALLEL==1
  // For waking up thread
  inline pthread_mutex_t * mutexPointer(int which,int thread=0) 
  { return mutex_+which+3*thread;}
  inline pthread_barrier_t * barrierPointer() 
  { return &barrier_;}
  inline int whichLocked(int thread=0) const
  { return locked_[thread];}
  inline CoinThreadInfo * threadInfoPointer(int thread=0) 
  { return threadInfo_+thread;}
  void startParallelStuff(int type);
  int stopParallelStuff(int type);
  int whichThread() const; 
#elif ABC_PARALLEL==2
  //inline CoinThreadInfo * threadInfoPointer(int thread=0) 
  //{ return threadInfo_+thread;}
#endif

  
  //-------------------------------------------------------------------------
  void setObjectiveCoefficient( int elementIndex, double elementValue );
  inline void setObjCoeff( int elementIndex, double elementValue ) {
    setObjectiveCoefficient( elementIndex, elementValue);
  }
  
  void setColumnLower( int elementIndex, double elementValue );
  
  void setColumnUpper( int elementIndex, double elementValue );
  
  void setColumnBounds( int elementIndex,
                        double lower, double upper );
  
  void setColumnSetBounds(const int* indexFirst,
                          const int* indexLast,
                          const double* boundList);
  
  inline void setColLower( int elementIndex, double elementValue ) {
    setColumnLower(elementIndex, elementValue);
  }
  inline void setColUpper( int elementIndex, double elementValue ) {
    setColumnUpper(elementIndex, elementValue);
  }
  
  inline void setColBounds( int elementIndex,
                            double newlower, double newupper ) {
    setColumnBounds(elementIndex, newlower, newupper);
  }
  
  inline void setColSetBounds(const int* indexFirst,
                              const int* indexLast,
                              const double* boundList) {
    setColumnSetBounds(indexFirst, indexLast, boundList);
  }
  
  void setRowLower( int elementIndex, double elementValue );
  
  void setRowUpper( int elementIndex, double elementValue ) ;
  
  void setRowBounds( int elementIndex,
                     double lower, double upper ) ;
  
  void setRowSetBounds(const int* indexFirst,
                       const int* indexLast,
                       const double* boundList);
  void resize (int newNumberRows, int newNumberColumns);
  
  
protected:
  
  double sumNonBasicCosts_;
  double rawObjectiveValue_;
  double objectiveOffset_;
  double perturbationFactor_;
  double currentDualTolerance_;
  double currentDualBound_;
  double largestGap_;
  double lastDualBound_;
  double sumFakeInfeasibilities_;
  double lastPrimalError_;
  double lastDualError_;
  double currentAcceptablePivot_;
  double movement_;
  double objectiveChange_;
  double btranAlpha_;
#ifdef ABC_LONG_FACTORIZATION 
  long
#endif
  double ftAlpha_;
  double minimumThetaMovement_;
  double initialSumInfeasibilities_;
public:
  int stateOfIteration_;
protected:
  int lastFirstFree_;
  int freeSequenceIn_;
  int maximumAbcNumberRows_;
  int maximumAbcNumberColumns_;
  int maximumNumberTotal_;
  int numberFlagged_;
  int normalDualColumnIteration_;
  int stateDualColumn_;
  /*
    May want to put some arrays into struct 
    Two arrays point to/from external
    Order is basic,unused basic, at lower, at upper, superbasic, free, fixed with starts
  */
  int numberTotal_;
  int numberTotalWithoutFixed_;
#define startAtLowerNoOther_ maximumAbcNumberRows_
  int startAtLowerOther_;
  int startAtUpperNoOther_;
  int startAtUpperOther_;
  int startOther_;
  int startFixed_;
#ifdef EARLY_FACTORIZE
  int numberEarly_;
#endif

#define ALL_STATUS_OK 2048
#define ROW_PRIMAL_OK 4096
#define ROW_DUAL_OK 8192
#define COLUMN_PRIMAL_OK 16384
#define COLUMN_DUAL_OK 32768
#define PESSIMISTIC 65536
#define ADD_A_BIT 131072
#define DO_SCALE_AND_MATRIX 262144
#define DO_BASIS_AND_ORDER 524288
#define DO_STATUS 1048576
#define DO_SOLUTION 2097152
#define DO_JUST_BOUNDS 0x400000
#define NEED_BASIS_SORT 0x800000
#define FAKE_SUPERBASIC 0x1000000
#define VALUES_PASS 0x2000000
#define VALUES_PASS2 0x4000000
  mutable int stateOfProblem_;
#if ABC_PARALLEL
public:
  int parallelMode_;
protected:
#endif
  int numberOrdinary_;
  int ordinaryVariables_;
  int numberFreeNonBasic_;
  int lastCleaned_;
  int lastPivotRow_;
  int swappedAlgorithm_;
  int initialNumberInfeasibilities_;
  //int * fromExternal_;
  //int * toExternal_;
  double * scaleFromExternal_;
  double * scaleToExternal_;
  double * columnUseScale_;
  double * inverseColumnUseScale_;
  double * offset_;
  double * offsetRhs_;
  double * tempArray_;
  unsigned char * internalStatus_;
  unsigned char * internalStatusSaved_;
  double * abcPerturbation_;
  double * perturbationSaved_;
  double * perturbationBasic_;
  AbcMatrix * abcMatrix_;
  double * abcLower_;
  double * abcUpper_;
  double * abcCost_;
  double * abcSolution_;
  double * abcDj_;
  double * lowerSaved_;
  double * upperSaved_;
  double * costSaved_;
  double * solutionSaved_;
  double * djSaved_;
  double * lowerBasic_;
  double * upperBasic_;
  double * costBasic_;
  double * solutionBasic_;
  double * djBasic_;
  AbcDualRowPivot * abcDualRowPivot_;
  AbcPrimalColumnPivot * abcPrimalColumnPivot_;
  int * abcPivotVariable_;
  int * reversePivotVariable_;
  AbcSimplexFactorization * abcFactorization_;
#ifdef EARLY_FACTORIZE
  AbcSimplexFactorization * abcEarlyFactorization_;
#endif
#ifdef TEMPORARY_FACTORIZATION
  AbcSimplexFactorization * abcOtherFactorization_;
#endif
  //double * savedSolution_;
  AbcSimplex * abcBaseModel_;
  ClpSimplex * clpModel_;
  AbcNonLinearCost * abcNonLinearCost_;
  /* has secondary offset and counts so row goes first then column
     Probably back to CoinPartitionedVector as AbcMatrix has slacks
     also says if in use - so we can just get next available one */
#define ABC_NUMBER_USEFUL 8
  mutable CoinPartitionedVector usefulArray_[ABC_NUMBER_USEFUL];
  AbcSimplexProgress abcProgress_;
  ClpDataSave saveData_;
  double upperTheta_;
  int multipleSequenceIn_[4];
public:
  int arrayForDualColumn_;
  int arrayForReplaceColumn_;
  int arrayForFlipBounds_; //2
  int arrayForFlipRhs_; // if sequential can re-use
  int arrayForBtran_; // 0
  int arrayForFtran_; // 1
  int arrayForTableauRow_; //3
protected:
  int numberFlipped_;
  int numberDisasters_;
  //int nextCleanNonBasicIteration_;
#if ABC_PARALLEL==1
  // For waking up thread
  pthread_mutex_t mutex_[3*NUMBER_THREADS];
  pthread_barrier_t barrier_; 
  CoinThreadInfo threadInfo_[NUMBER_THREADS];
  pthread_t abcThread_[NUMBER_THREADS];
  int locked_[NUMBER_THREADS];
  int stopStart_;
#elif ABC_PARALLEL==2
  //CoinThreadInfo threadInfo_[NUMBER_THREADS];
#endif

};
//#############################################################################
void
AbcSimplexUnitTest(const std::string & mpsDir);
#endif