ClpSimplex.hpp

Go to the documentation of this file.

/* $Id: ClpSimplex.hpp 2114 2015-02-10 12:12:46Z forrest $ */
// Copyright (C) 2002, 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 ClpSimplex_H
#define ClpSimplex_H

#include <iostream>
#include <cfloat>
#include "ClpModel.hpp"
#include "ClpMatrixBase.hpp"
#include "ClpSolve.hpp"
#include "ClpConfig.h"
class ClpDualRowPivot;
class ClpPrimalColumnPivot;
class ClpFactorization;
class CoinIndexedVector;
class ClpNonLinearCost;
class ClpNodeStuff;
class CoinStructuredModel;
class OsiClpSolverInterface;
class CoinWarmStartBasis;
class ClpDisasterHandler;
class ClpConstraint;
/*
  May want to use Clp defaults so that with ABC defined but not used
  it behaves as Clp (and ABC used will be different than if not defined)
 */
#ifdef ABC_INHERIT
#ifndef CLP_INHERIT_MODE
#define CLP_INHERIT_MODE 1
#endif
#ifndef ABC_CLP_DEFAULTS
#define ABC_CLP_DEFAULTS 0
#endif
#else
#undef ABC_CLP_DEFAULTS
#define ABC_CLP_DEFAULTS 1
#endif
#ifdef CLP_HAS_ABC
#include "AbcCommon.hpp"
class AbcTolerancesEtc;
class AbcSimplex;
#include "CoinAbcCommon.hpp"
#endif

class ClpSimplex : public ClpModel {
     friend void ClpSimplexUnitTest(const std::string & mpsDir);

public:
     enum Status {
          isFree = 0x00,
          basic = 0x01,
          atUpperBound = 0x02,
          atLowerBound = 0x03,
          superBasic = 0x04,
          isFixed = 0x05
     };
     // For Dual
     enum FakeBound {
          noFake = 0x00,
          lowerFake = 0x01,
          upperFake = 0x02,
          bothFake = 0x03
     };

     ClpSimplex (bool emptyMessages = false  );

     ClpSimplex(const ClpSimplex & rhs, int scalingMode = -1);
     ClpSimplex(const ClpModel & rhs, int scalingMode = -1);
     ClpSimplex (const ClpModel * wholeModel,
                 int numberRows, const int * whichRows,
                 int numberColumns, const int * whichColumns,
                 bool dropNames = true, bool dropIntegers = true,
                 bool fixOthers = false);
     ClpSimplex (const ClpSimplex * wholeModel,
                 int numberRows, const int * whichRows,
                 int numberColumns, const int * whichColumns,
                 bool dropNames = true, bool dropIntegers = true,
                 bool fixOthers = false);
     ClpSimplex (ClpSimplex * wholeModel,
                 int numberColumns, const int * whichColumns);
     void originalModel(ClpSimplex * miniModel);
  inline int abcState() const
  { return abcState_;}
  inline void setAbcState(int state)
  { abcState_=state;}
#ifdef ABC_INHERIT
  inline AbcSimplex * abcSimplex() const
  { return abcSimplex_;}
  inline void setAbcSimplex(AbcSimplex * simplex)
  { abcSimplex_=simplex;}
  int doAbcDual();
  int doAbcPrimal(int ifValuesPass);
#endif

     void setPersistenceFlag(int value);
     void makeBaseModel();
     void deleteBaseModel();
     inline ClpSimplex *  baseModel() const {
          return baseModel_;
     }
     void setToBaseModel(ClpSimplex * model = NULL);
     ClpSimplex & operator=(const ClpSimplex & rhs);
     ~ClpSimplex (  );
     // Ones below are just ClpModel with some changes
     void loadProblem (  const ClpMatrixBase& matrix,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);
     void loadProblem (  const CoinPackedMatrix& matrix,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);

     void loadProblem (  const int numcols, const int numrows,
                         const CoinBigIndex* start, const int* index,
                         const double* value,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);
     void loadProblem (  const int numcols, const int numrows,
                         const CoinBigIndex* start, const int* index,
                         const double* value, const int * length,
                         const double* collb, const double* colub,
                         const double* obj,
                         const double* rowlb, const double* rowub,
                         const double * rowObjective = NULL);
     int loadProblem (  CoinModel & modelObject, bool keepSolution = false);
     int readMps(const char *filename,
                 bool keepNames = false,
                 bool ignoreErrors = false);
     int readGMPL(const char *filename, const char * dataName,
                  bool keepNames = false);
     int readLp(const char *filename, const double epsilon = 1e-5);
     void borrowModel(ClpModel & otherModel);
     void borrowModel(ClpSimplex & otherModel);
     void passInEventHandler(const ClpEventHandler * eventHandler);
     void getbackSolution(const ClpSimplex & smallModel, const int * whichRow, const int * whichColumn);
     int loadNonLinear(void * info, int & numberConstraints,
                       ClpConstraint ** & constraints);
#ifdef ABC_INHERIT
  void loadTolerancesEtc(const AbcTolerancesEtc & data);
  void unloadTolerancesEtc(AbcTolerancesEtc & data);
#endif


     int initialSolve(ClpSolve & options);
     int initialSolve();
     int initialDualSolve();
     int initialPrimalSolve();
     int initialBarrierSolve();
     int initialBarrierNoCrossSolve();
     int dual(int ifValuesPass = 0, int startFinishOptions = 0);
     // If using Debug
     int dualDebug(int ifValuesPass = 0, int startFinishOptions = 0);
     int primal(int ifValuesPass = 0, int startFinishOptions = 0);
     int nonlinearSLP(int numberPasses, double deltaTolerance);
     int nonlinearSLP(int numberConstraints, ClpConstraint ** constraints,
                      int numberPasses, double deltaTolerance);
     int barrier(bool crossover = true);
     int reducedGradient(int phase = 0);
     int solve(CoinStructuredModel * model);
#ifdef ABC_INHERIT

  AbcSimplex * dealWithAbc(int solveType,int startUp,bool interrupt=false);
  //void dealWithAbc(int solveType,int startUp,bool interrupt=false);
#endif

     int loadProblem (  CoinStructuredModel & modelObject,
                        bool originalOrder = true, bool keepSolution = false);
     int cleanup(int cleanupScaling);
     int dualRanging(int numberCheck, const int * which,
                     double * costIncrease, int * sequenceIncrease,
                     double * costDecrease, int * sequenceDecrease,
                     double * valueIncrease = NULL, double * valueDecrease = NULL);
     int primalRanging(int numberCheck, const int * which,
                       double * valueIncrease, int * sequenceIncrease,
                       double * valueDecrease, int * sequenceDecrease);
     int modifyCoefficientsAndPivot(int number,
                                 const int * which,
                                 const CoinBigIndex * start,
                                 const int * row,
                                 const double * newCoefficient,
                                 const unsigned char * newStatus=NULL,
                                 const double * newLower=NULL,
                                 const double * newUpper=NULL,
                                 const double * newObjective=NULL);
     int outDuplicateRows(int numberLook,int * whichRows, bool noOverlaps=false, double tolerance=-1.0,
                          double cleanUp=0.0);
     double moveTowardsPrimalFeasible();
     void removeSuperBasicSlacks(int threshold=0);
     ClpSimplex * miniPresolve(char * rowType, char * columnType,void ** info);
     void miniPostsolve(const ClpSimplex * presolvedModel,void * info);
     void miniSolve(char * rowType, char *columnType,int algorithm, int startUp);
     int writeBasis(const char *filename,
                    bool writeValues = false,
                    int formatType = 0) const;
     int readBasis(const char *filename);
     CoinWarmStartBasis * getBasis() const;
     void setFactorization( ClpFactorization & factorization);
     // Swaps factorization
     ClpFactorization * swapFactorization( ClpFactorization * factorization);
     void copyFactorization( ClpFactorization & factorization);
     int tightenPrimalBounds(double factor = 0.0, int doTight = 0, bool tightIntegers = false);
     int crash(double gap, int pivot);
     void setDualRowPivotAlgorithm(ClpDualRowPivot & choice);
     void setPrimalColumnPivotAlgorithm(ClpPrimalColumnPivot & choice);
     void markHotStart(void * & saveStuff);
     void solveFromHotStart(void * saveStuff);
     void unmarkHotStart(void * saveStuff);
     int strongBranching(int numberVariables, const int * variables,
                         double * newLower, double * newUpper,
                         double ** outputSolution,
                         int * outputStatus, int * outputIterations,
                         bool stopOnFirstInfeasible = true,
                         bool alwaysFinish = false,
                         int startFinishOptions = 0);
     int fathom(void * stuff);
     int fathomMany(void * stuff);
     double doubleCheck();
     int startFastDual2(ClpNodeStuff * stuff);
     int fastDual2(ClpNodeStuff * stuff);
     void stopFastDual2(ClpNodeStuff * stuff);
     ClpSimplex * fastCrunch(ClpNodeStuff * stuff, int mode);

     int pivot();

     int primalPivotResult();

     int dualPivotResultPart1();
  int pivotResultPart2(int algorithm,int state);

     int startup(int ifValuesPass, int startFinishOptions = 0);
     void finish(int startFinishOptions = 0);

     bool statusOfProblem(bool initial = false);
     void defaultFactorizationFrequency();
     void copyEnabledStuff(const ClpSimplex * rhs);

     inline bool primalFeasible() const {
          return (numberPrimalInfeasibilities_ == 0);
     }
     inline bool dualFeasible() const {
          return (numberDualInfeasibilities_ == 0);
     }
     inline ClpFactorization * factorization() const {
          return factorization_;
     }
     bool sparseFactorization() const;
     void setSparseFactorization(bool value);
     int factorizationFrequency() const;
     void setFactorizationFrequency(int value);
     inline double dualBound() const {
          return dualBound_;
     }
     void setDualBound(double value);
     inline double infeasibilityCost() const {
          return infeasibilityCost_;
     }
     void setInfeasibilityCost(double value);
     inline int perturbation() const {
          return perturbation_;
     }
     void setPerturbation(int value);
     inline int algorithm() const {
          return algorithm_;
     }
     inline void setAlgorithm(int value) {
          algorithm_ = value;
     }
     bool isObjectiveLimitTestValid() const ;
     inline double sumDualInfeasibilities() const {
          return sumDualInfeasibilities_;
     }
     inline void setSumDualInfeasibilities(double value) {
          sumDualInfeasibilities_ = value;
     }
     inline double sumOfRelaxedDualInfeasibilities() const {
          return sumOfRelaxedDualInfeasibilities_;
     }
     inline void setSumOfRelaxedDualInfeasibilities(double value) {
          sumOfRelaxedDualInfeasibilities_ = value;
     }
     inline int numberDualInfeasibilities() const {
          return numberDualInfeasibilities_;
     }
     inline void setNumberDualInfeasibilities(int value) {
          numberDualInfeasibilities_ = value;
     }
     inline int numberDualInfeasibilitiesWithoutFree() const {
          return numberDualInfeasibilitiesWithoutFree_;
     }
     inline double sumPrimalInfeasibilities() const {
          return sumPrimalInfeasibilities_;
     }
     inline void setSumPrimalInfeasibilities(double value) {
          sumPrimalInfeasibilities_ = value;
     }
     inline double sumOfRelaxedPrimalInfeasibilities() const {
          return sumOfRelaxedPrimalInfeasibilities_;
     }
     inline void setSumOfRelaxedPrimalInfeasibilities(double value) {
          sumOfRelaxedPrimalInfeasibilities_ = value;
     }
     inline int numberPrimalInfeasibilities() const {
          return numberPrimalInfeasibilities_;
     }
     inline void setNumberPrimalInfeasibilities(int value) {
          numberPrimalInfeasibilities_ = value;
     }
     int saveModel(const char * fileName);
     int restoreModel(const char * fileName);

     void checkSolution(int setToBounds = 0);
     void checkSolutionInternal();
     void checkUnscaledSolution();
     inline CoinIndexedVector * rowArray(int index) const {
          return rowArray_[index];
     }
     inline CoinIndexedVector * columnArray(int index) const {
          return columnArray_[index];
     }

     /******************** End of most useful part **************/
     int getSolution (  const double * rowActivities,
                        const double * columnActivities);
     int getSolution ();
     int createPiecewiseLinearCosts(const int * starts,
                                    const double * lower, const double * gradient);
     inline ClpDualRowPivot * dualRowPivot() const {
          return dualRowPivot_;
     }
     inline ClpPrimalColumnPivot * primalColumnPivot() const {
          return primalColumnPivot_;
     }
     inline bool goodAccuracy() const {
          return (largestPrimalError_ < 1.0e-7 && largestDualError_ < 1.0e-7);
     }
     void returnModel(ClpSimplex & otherModel);
     int internalFactorize(int solveType);
     ClpDataSave saveData() ;
     void restoreData(ClpDataSave saved);
     void cleanStatus();
     int factorize();
     void computeDuals(double * givenDjs);
     void computePrimals (  const double * rowActivities,
                            const double * columnActivities);
     void add(double * array,
              int column, double multiplier) const;
     void unpack(CoinIndexedVector * rowArray) const ;
     void unpack(CoinIndexedVector * rowArray, int sequence) const;
     void unpackPacked(CoinIndexedVector * rowArray) ;
     void unpackPacked(CoinIndexedVector * rowArray, int sequence);
#ifndef CLP_USER_DRIVEN
protected:
#endif

     int housekeeping(double objectiveChange);
     void checkPrimalSolution(const double * rowActivities = NULL,
                              const double * columnActivies = NULL);
     void checkDualSolution();
     void checkBothSolutions();
     double scaleObjective(double value);
    int solveDW(CoinStructuredModel * model, ClpSolve & options);
     int solveBenders(CoinStructuredModel * model, ClpSolve & options);
public:
     void setValuesPassAction(double incomingInfeasibility,
                              double allowedInfeasibility);
     int cleanFactorization(int ifValuesPass);

public:
     inline double alphaAccuracy() const {
          return alphaAccuracy_;
     }
     inline void setAlphaAccuracy(double value) {
          alphaAccuracy_ = value;
     }
public:
     //inline double objectiveValue() const {
     //return (objectiveValue_-bestPossibleImprovement_)*optimizationDirection_ - dblParam_[ClpObjOffset];
     //}
     inline void setDisasterHandler(ClpDisasterHandler * handler) {
          disasterArea_ = handler;
     }
     inline ClpDisasterHandler * disasterHandler() const {
          return disasterArea_;
     }
     inline double largeValue() const {
          return largeValue_;
     }
     void setLargeValue( double value) ;
     inline double largestPrimalError() const {
          return largestPrimalError_;
     }
     inline double largestDualError() const {
          return largestDualError_;
     }
     inline void setLargestPrimalError(double value) {
          largestPrimalError_ = value;
     }
     inline void setLargestDualError(double value) {
          largestDualError_ = value;
     }
     inline double zeroTolerance() const {
          return zeroTolerance_;/*factorization_->zeroTolerance();*/
     }
     inline void setZeroTolerance( double value) {
          zeroTolerance_ = value;
     }
     inline int * pivotVariable() const {
          return pivotVariable_;
     }
     inline bool automaticScaling() const {
          return automaticScale_ != 0;
     }
     inline void setAutomaticScaling(bool onOff) {
          automaticScale_ = onOff ? 1 : 0;
     }
     inline double currentDualTolerance() const {
          return dualTolerance_;
     }
     inline void setCurrentDualTolerance(double value) {
          dualTolerance_ = value;
     }
     inline double currentPrimalTolerance() const {
          return primalTolerance_;
     }
     inline void setCurrentPrimalTolerance(double value) {
          primalTolerance_ = value;
     }
     inline int numberRefinements() const {
          return numberRefinements_;
     }
     void setNumberRefinements( int value) ;
     inline double alpha() const {
          return alpha_;
     }
     inline void setAlpha(double value) {
          alpha_ = value;
     }
     inline double dualIn() const {
          return dualIn_;
     }
     inline void setDualIn(double value) {
          dualIn_ = value;
     }
     inline int pivotRow() const {
          return pivotRow_;
     }
     inline void setPivotRow(int value) {
          pivotRow_ = value;
     }
     double valueIncomingDual() const;

#ifndef CLP_USER_DRIVEN
protected:
#endif

     int gutsOfSolution ( double * givenDuals,
                          const double * givenPrimals,
                          bool valuesPass = false);
     void gutsOfDelete(int type);
     void gutsOfCopy(const ClpSimplex & rhs);
     bool createRim(int what, bool makeRowCopy = false, int startFinishOptions = 0);
     void createRim1(bool initial);
     void createRim4(bool initial);
     void createRim5(bool initial);
     void deleteRim(int getRidOfFactorizationData = 2);
     bool sanityCheck();
public:
     inline double * solutionRegion(int section) const {
          if (!section) return rowActivityWork_;
          else return columnActivityWork_;
     }
     inline double * djRegion(int section) const {
          if (!section) return rowReducedCost_;
          else return reducedCostWork_;
     }
     inline double * lowerRegion(int section) const {
          if (!section) return rowLowerWork_;
          else return columnLowerWork_;
     }
     inline double * upperRegion(int section) const {
          if (!section) return rowUpperWork_;
          else return columnUpperWork_;
     }
     inline double * costRegion(int section) const {
          if (!section) return rowObjectiveWork_;
          else return objectiveWork_;
     }
     inline double * solutionRegion() const {
          return solution_;
     }
     inline double * djRegion() const {
          return dj_;
     }
     inline double * lowerRegion() const {
          return lower_;
     }
     inline double * upperRegion() const {
          return upper_;
     }
     inline double * costRegion() const {
          return cost_;
     }
     inline Status getStatus(int sequence) const {
          return static_cast<Status> (status_[sequence] & 7);
     }
     inline void setStatus(int sequence, Status newstatus) {
          unsigned char & st_byte = status_[sequence];
          st_byte = static_cast<unsigned char>(st_byte & ~7);
          st_byte = static_cast<unsigned char>(st_byte | newstatus);
     }
     bool startPermanentArrays();
     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;
     }
     inline int directionIn() const {
          return directionIn_;
     }
     inline int directionOut() const {
          return directionOut_;
     }
     inline void  setDirectionIn(int direction) {
          directionIn_ = direction;
     }
     inline void  setDirectionOut(int direction) {
          directionOut_ = direction;
     }
     inline double valueOut() const {
          return valueOut_;
     }
     inline void setValueOut(double value) {
          valueOut_ = value;
     }
     inline double dualOut() const {
          return dualOut_;
     }
     inline void setDualOut(double value) {
          dualOut_ = value;
     }
     inline void setLowerOut(double value) {
          lowerOut_ = value;
     }
     inline void setUpperOut(double value) {
          upperOut_ = value;
     }
     inline void setTheta(double value) {
          theta_ = value;
     }
     inline int isColumn(int sequence) const {
          return sequence < numberColumns_ ? 1 : 0;
     }
     inline int sequenceWithin(int sequence) const {
          return sequence < numberColumns_ ? sequence : sequence - numberColumns_;
     }
     inline double solution(int sequence) {
          return solution_[sequence];
     }
     inline double & solutionAddress(int sequence) {
          return solution_[sequence];
     }
     inline double reducedCost(int sequence) {
          return dj_[sequence];
     }
     inline double & reducedCostAddress(int sequence) {
          return dj_[sequence];
     }
     inline double lower(int sequence) {
          return lower_[sequence];
     }
     inline double & lowerAddress(int sequence) {
          return lower_[sequence];
     }
     inline double upper(int sequence) {
          return upper_[sequence];
     }
     inline double & upperAddress(int sequence) {
          return upper_[sequence];
     }
     inline double cost(int sequence) {
          return cost_[sequence];
     }
     inline double & costAddress(int sequence) {
          return cost_[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 double theta() const {
          return theta_;
     }
     inline double bestPossibleImprovement() const {
          return bestPossibleImprovement_;
     }
     inline ClpNonLinearCost * nonLinearCost() const {
          return nonLinearCost_;
     }
     inline int moreSpecialOptions() const {
          return moreSpecialOptions_;
     }
     inline void setMoreSpecialOptions(int value) {
          moreSpecialOptions_ = value;
     }

     inline void setFakeBound(int sequence, FakeBound fakeBound) {
          unsigned char & st_byte = status_[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> ((status_[sequence] >> 3) & 3);
     }
     inline void setRowStatus(int sequence, Status newstatus) {
          unsigned char & st_byte = status_[sequence+numberColumns_];
          st_byte = static_cast<unsigned char>(st_byte & ~7);
          st_byte = static_cast<unsigned char>(st_byte | newstatus);
     }
     inline Status getRowStatus(int sequence) const {
          return static_cast<Status> (status_[sequence+numberColumns_] & 7);
     }
     inline void setColumnStatus(int sequence, Status newstatus) {
          unsigned char & st_byte = status_[sequence];
          st_byte = static_cast<unsigned char>(st_byte & ~7);
          st_byte = static_cast<unsigned char>(st_byte | newstatus);
     }
     inline Status getColumnStatus(int sequence) const {
          return static_cast<Status> (status_[sequence] & 7);
     }
     inline void setPivoted( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] | 32);
     }
     inline void clearPivoted( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~32);
     }
     inline bool pivoted(int sequence) const {
          return (((status_[sequence] >> 5) & 1) != 0);
     }
     void setFlagged( int sequence);
     inline void clearFlagged( int sequence) {
          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~64);
     }
     inline bool flagged(int sequence) const {
          return ((status_[sequence] & 64) != 0);
     }
     inline void setActive( int iRow) {
          status_[iRow] = static_cast<unsigned char>(status_[iRow] | 128);
     }
     inline void clearActive( int iRow) {
          status_[iRow] = static_cast<unsigned char>(status_[iRow] & ~128);
     }
     inline bool active(int iRow) const {
          return ((status_[iRow] & 128) != 0);
     }
     inline void setPerturbed( int iSequence) {
          status_[iSequence] = static_cast<unsigned char>(status_[iSequence] | 128);
     }
     inline void clearPerturbed( int iSequence) {
          status_[iSequence] = static_cast<unsigned char>(status_[iSequence] & ~128);
     }
     inline bool perturbed(int iSequence) const {
          return ((status_[iSequence] & 128) != 0);
     }
     void createStatus() ;
     void allSlackBasis(bool resetSolution = false);

     inline int lastBadIteration() const {
          return lastBadIteration_;
     }
     inline void setLastBadIteration(int value) {
          lastBadIteration_=value;
     }
     inline int progressFlag() const {
          return (progressFlag_ & 3);
     }
     inline ClpSimplexProgress * progress()
     { return &progress_;}
     inline int forceFactorization() const {
          return forceFactorization_ ;
     }
     inline void forceFactorization(int value) {
          forceFactorization_ = value;
     }
     inline double rawObjectiveValue() const {
          return objectiveValue_;
     }
     void computeObjectiveValue(bool useWorkingSolution = false);
     double computeInternalObjectiveValue();
     double * infeasibilityRay(bool fullRay=false) const;
     inline int numberExtraRows() const {
          return numberExtraRows_;
     }
     inline int maximumBasic() const {
          return maximumBasic_;
     }
     inline int baseIteration() const {
          return baseIteration_;
     }
     void generateCpp( FILE * fp, bool defaultFactor = false);
     ClpFactorization * getEmptyFactorization();
     void setEmptyFactorization();
     void moveInfo(const ClpSimplex & rhs, bool justStatus = false);

     // These are only to be used using startFinishOptions (ClpSimplexDual, ClpSimplexPrimal)
     // *** At present only without scaling
     // *** Slacks havve -1.0 element (so == row activity) - take care
     void getBInvARow(int row, double* z, double * slack = NULL);

     void getBInvRow(int row, double* z);

     void getBInvACol(int col, double* vec);

     void getBInvCol(int col, double* vec);

     void getBasics(int* index);

     //-------------------------------------------------------------------------
     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 bestPossibleImprovement_;
     double zeroTolerance_;
     int columnPrimalSequence_;
     int rowPrimalSequence_;
     double bestObjectiveValue_;
     int moreSpecialOptions_;
     int baseIteration_;
     double primalToleranceToGetOptimal_;
     double largeValue_;
     double largestPrimalError_;
     double largestDualError_;
     double alphaAccuracy_;
     double dualBound_;
     double alpha_;
     double theta_;
     double lowerIn_;
     double valueIn_;
     double upperIn_;
     double dualIn_;
     double lowerOut_;
     double valueOut_;
     double upperOut_;
     double dualOut_;
     double dualTolerance_;
     double primalTolerance_;
     double sumDualInfeasibilities_;
     double sumPrimalInfeasibilities_;
     double infeasibilityCost_;
     double sumOfRelaxedDualInfeasibilities_;
     double sumOfRelaxedPrimalInfeasibilities_;
     double acceptablePivot_;
     double minimumPrimalTolerance_;
#define CLP_INFEAS_SAVE 5
     double averageInfeasibility_[CLP_INFEAS_SAVE];
     double * lower_;
     double * rowLowerWork_;
     double * columnLowerWork_;
     double * upper_;
     double * rowUpperWork_;
     double * columnUpperWork_;
     double * cost_;
     double * rowObjectiveWork_;
     double * objectiveWork_;
     CoinIndexedVector * rowArray_[6];
     CoinIndexedVector * columnArray_[6];
     int sequenceIn_;
     int directionIn_;
     int sequenceOut_;
     int directionOut_;
     int pivotRow_;
     int lastGoodIteration_;
     double * dj_;
     double * rowReducedCost_;
     double * reducedCostWork_;
     double * solution_;
     double * rowActivityWork_;
     double * columnActivityWork_;
     int numberDualInfeasibilities_;
     int numberDualInfeasibilitiesWithoutFree_;
     int numberPrimalInfeasibilities_;
     int numberRefinements_;
     ClpDualRowPivot * dualRowPivot_;
     ClpPrimalColumnPivot * primalColumnPivot_;
     int * pivotVariable_;
     ClpFactorization * factorization_;
     double * savedSolution_;
     int numberTimesOptimal_;
     ClpDisasterHandler * disasterArea_;
     int changeMade_;
     int algorithm_;
     int forceFactorization_;
     int perturbation_;
     unsigned char * saveStatus_;
     ClpNonLinearCost * nonLinearCost_;
     int lastBadIteration_;
     int lastFlaggedIteration_;
     int numberFake_;
     int numberChanged_;
     int progressFlag_;
     int firstFree_;
     int numberExtraRows_;
     int maximumBasic_;
     int dontFactorizePivots_;
     double incomingInfeasibility_;
     double allowedInfeasibility_;
     int automaticScale_;
     int maximumPerturbationSize_;
     double * perturbationArray_;
     ClpSimplex * baseModel_;
     ClpSimplexProgress progress_;
#ifdef ABC_INHERIT
  AbcSimplex * abcSimplex_;
#define CLP_ABC_WANTED 1
#define CLP_ABC_WANTED_PARALLEL 2
#define CLP_ABC_FULL_DONE 8
  // bits 256,512,1024 for crash
#endif
#define CLP_ABC_BEEN_FEASIBLE 65536
  int abcState_;
  int numberDegeneratePivots_;
public:
     mutable int spareIntArray_[4];
     mutable double spareDoubleArray_[4];
protected:
     friend class OsiClpSolverInterface;
     friend class OsiCLPSolverInterface;
};
//#############################################################################
void
ClpSimplexUnitTest(const std::string & mpsDir);

// For Devex stuff
#define DEVEX_TRY_NORM 1.0e-4
#define DEVEX_ADD_ONE 1.0
#if defined(ABC_INHERIT) || defined(CBC_THREAD) || defined(THREADS_IN_ANALYZE)
// Use pthreads
#include <pthread.h>
typedef struct {
  double result;
  //const CoinIndexedVector * constVector; // can get rid of
  //CoinIndexedVector * vectors[2]; // can get rid of
  void * extraInfo;
  void * extraInfo2;
  int status;
  int stuff[4];
} CoinThreadInfo;
class CoinPthreadStuff {
public:
  CoinPthreadStuff (int numberThreads=0,
                    void * parallelManager(void * stuff)=NULL);
  CoinPthreadStuff & operator=(const CoinPthreadStuff & rhs);
  ~CoinPthreadStuff (  );
  inline void setStopStart(int value)
  { stopStart_=value;}
#ifndef NUMBER_THREADS 
#define NUMBER_THREADS 8
#endif
  // For waking up thread
  inline pthread_mutex_t * mutexPointer(int which,int thread=0) 
  { return mutex_+which+3*thread;}
#ifdef PTHREAD_BARRIER_SERIAL_THREAD
  inline pthread_barrier_t * barrierPointer() 
  { return &barrier_;}
#endif
  inline int whichLocked(int thread=0) const
  { return locked_[thread];}
  inline CoinThreadInfo * threadInfoPointer(int thread=0) 
  { return threadInfo_+thread;}
  void startParallelTask(int type,int iThread,void * info=NULL);
  int waitParallelTask(int type, int & iThread,bool allowIdle);
  void waitAllTasks();
  int whichThread() const;
  void sayIdle(int iThread);
  //void startThreads(int numberThreads);
  //void stopThreads();
  // For waking up thread
  pthread_mutex_t mutex_[3*(NUMBER_THREADS+1)];
#ifdef PTHREAD_BARRIER_SERIAL_THREAD
  pthread_barrier_t barrier_; 
#endif
  CoinThreadInfo threadInfo_[NUMBER_THREADS+1];
  pthread_t abcThread_[NUMBER_THREADS+1];
  int locked_[NUMBER_THREADS+1];
  int stopStart_;
  int numberThreads_;
};
void * clp_parallelManager(void * stuff);
#endif
#endif