AbcSimplex.hpp

Go to the documentation of this file.

/* $Id$ */
// 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/