ClpSimplex.hpp

Go to the documentation of this file.

/* $Id$ */
// 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"
#include "CoinIndexedVector.hpp"
class ClpDualRowPivot;
class ClpPrimalColumnPivot;
class ClpFactorization;
class CoinFactorization;
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
#ifndef ABC_INHERIT
#if ABOCA_LITE
#ifndef FAKE_CILK
#include <cilk/cilk.h>
#else
#undef cilk_for
#undef cilk_spawn
#undef cilk_sync
#define cilk_for for
#define cilk_spawn
#define cilk_sync
#endif
#ifndef LONG_REGION_2
#define LONG_REGION_2 1
#endif
#define SHORT_REGION 1
#else
#define cilk_spawn
#define cilk_sync
#endif
#ifdef LONG_REGION_2
#define SHORT_REGION 1
#else
#define SHORT_REGION 2
#endif
// for now keep simple
#undef LONG_REGION_2
#undef SHORT_REGION
#define SHORT_REGION 2
#else
//ABC_INHERIT
#define LONG_REGION_2 1
#define SHORT_REGION 1
#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);
#ifdef ABC_INHERIT
  inline int abcState() const
  {
    return abcState_;
  }
  inline void setAbcState(int state)
  {
    abcState_ = state;
  }
  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 writeLp(const char *filename,
    const char *extension = "lp",
    double epsilon = 1e-5,
    int numberAcross = 10,
    int decimals = 5,
    double objSense = 0.0,
    bool useRowNames = true) const;
  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 cleanPrimalSolution(double exactMultiple);
  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 double lowerOut() const
  {
    return lowerOut_;
  }
  inline double upperOut() const
  {
    return upperOut_;
  }
  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 lowerIn() const
  {
    return lowerIn_;
  }
  inline double valueIn() const
  {
    return valueIn_;
  }
  inline double upperIn() const
  {
    return upperIn_;
  }
  inline double bestPossibleImprovement() const
  {
    return bestPossibleImprovement_;
  }
  inline ClpNonLinearCost *nonLinearCost() const
  {
    return nonLinearCost_;
  }
  void setNonLinearCost(ClpNonLinearCost &nonLinearCost);
  inline int moreSpecialOptions() const
  {
    return moreSpecialOptions_;
  }
  inline int vectorMode() const
  {
    return vectorMode_;
  }
  inline void setMoreSpecialOptions(int value)
  {
    moreSpecialOptions_ = value;
  }
  inline void setVectorMode(int value)
  {
    vectorMode_ = 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_;
  int vectorMode_;
  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_;
  int abcState_;
#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 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(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
typedef struct {
  double upperTheta;
  double bestPossible;
  double acceptablePivot;
  double tolerance;
  double dualTolerance;
  double theta;
  double primalRatio;
  double changeObj;
  const double *COIN_RESTRICT cost;
  double *COIN_RESTRICT solution;
  double *COIN_RESTRICT reducedCost;
  const double *COIN_RESTRICT lower;
  const double *COIN_RESTRICT upper;
  double *COIN_RESTRICT work;
  int *COIN_RESTRICT index;
  double *COIN_RESTRICT spare;
  const unsigned char *COIN_RESTRICT status;
  int *COIN_RESTRICT which;
  double *COIN_RESTRICT infeas;
  const int *COIN_RESTRICT pivotVariable;
  const double *COIN_RESTRICT element;
  const CoinBigIndex *COIN_RESTRICT start;
  const int *COIN_RESTRICT row;
  int numberAdded;
  int numberInfeasibilities;
  int numberRemaining;
  int startColumn;
  int numberToDo;
  int numberColumns;
} clpTempInfo;
#ifndef ABC_INHERIT
#if ABOCA_LITE
void moveAndZero(clpTempInfo *info, int type, void *extra);
// 2 is owner of abcState_
#ifdef ABCSTATE_LITE
#if ABCSTATE_LITE == 2
int abcState_ = 0;
#else
extern int abcState_;
#endif
inline int abcState()
{
  return abcState_;
}
inline void setAbcState(int state)
{
  abcState_ = state;
}
#endif
#else
#define abcState 0
#endif
#endif
#ifdef CLP_USER_DRIVEN
// expand as needed
typedef struct {
  double alpha;
  double totalThru;
  double rhs;
  double value;
  double lower;
  double upper;
  double cost;
  int type;
  int row;
  int sequence;
  int printing;
  int change;
} clpUserStruct;
#endif
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/