Loading...
Searching...
No Matches
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
*/
AbcCommon.hpp
NUMBER_THREADS
#define NUMBER_THREADS
Definition AbcSimplex.hpp:1028
AbcSimplexUnitTest
void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
ABC_NUMBER_USEFUL
#define ABC_NUMBER_USEFUL
Useful arrays (all of row+column+2 length).
Definition AbcSimplex.hpp:1419
rowUseScale_
#define rowUseScale_
Definition AbcSimplex.hpp:413
inverseRowUseScale_
#define inverseRowUseScale_
Definition AbcSimplex.hpp:414
AbcSimplex
#define AbcSimplex
Definition AbcWarmStart.hpp:16
type
CbcOrClpParameterType type() const
type
Definition CbcOrClpParam.hpp:462
ClpMatrixBase.hpp
ClpModel.hpp
ROW_LOWER_SAME
#define ROW_LOWER_SAME
Definition ClpModel.hpp:1339
COLUMN_UPPER_SAME
#define COLUMN_UPPER_SAME
Definition ClpModel.hpp:1343
COLUMN_LOWER_SAME
#define COLUMN_LOWER_SAME
Definition ClpModel.hpp:1342
ClpObjOffset
@ ClpObjOffset
Objective function constant.
Definition ClpParameters.hpp:60
ClpSimplex.hpp
ClpSolve.hpp
CoinAbcCommon.hpp
AbcDualRowPivot
Dual Row Pivot Abstract Base Class.
Definition AbcDualRowPivot.hpp:23
AbcMatrix
Definition AbcMatrix.hpp:22
AbcNonLinearCost
Definition AbcNonLinearCost.hpp:71
AbcPrimalColumnPivot
Primal Column Pivot Abstract Base Class.
Definition AbcPrimalColumnPivot.hpp:26
AbcSimplexFactorization
This just implements AbcFactorization when an AbcMatrix object is passed.
Definition AbcSimplexFactorization.hpp:26
AbcSimplex::restoreGoodStatus
void restoreGoodStatus(int type)
Restores previous good status and says trouble.
AbcSimplex::housekeeping
int housekeeping()
This does basis housekeeping and does values for in/out variables.
AbcSimplex::initialNumberInfeasibilities_
int initialNumberInfeasibilities_
Initial number of infeasibilities.
Definition AbcSimplex.hpp:1307
AbcSimplex::moveStatusToClp
void moveStatusToClp(ClpSimplex *clpModel)
Move status and solution to ClpSimplex.
AbcSimplex::checkArrays
void checkArrays(int ignoreEmpty=0) const
For debug - prints summary of arrays which are out of kilter.
AbcSimplex::AbcSimplex
AbcSimplex(const AbcSimplex &rhs)
Copy constructor.
AbcSimplex::costSaved_
double * costSaved_
Saved scaled copy of objective.
Definition AbcSimplex.hpp:1369
AbcSimplex::abcPerturbation
double * abcPerturbation() const
Perturbation.
Definition AbcSimplex.hpp:653
AbcSimplex::normalDualColumnIteration_
int normalDualColumnIteration_
Iteration at which to do relaxed dualColumn.
Definition AbcSimplex.hpp:1221
AbcSimplex::startOther_
int startOther_
Start of superBasic, free or awkward bounds variables.
Definition AbcSimplex.hpp:1246
AbcSimplex::largestGap_
double largestGap_
Largest gap.
Definition AbcSimplex.hpp:1176
AbcSimplex::setValuesPassAction
void setValuesPassAction(double incomingInfeasibility, double allowedInfeasibility)
For advanced use.
AbcSimplex::setFakeBound
void setFakeBound(int sequence, FakeBound fakeBound)
Definition AbcSimplex.hpp:942
AbcSimplex::arrayForFlipRhs
int arrayForFlipRhs() const
Definition AbcSimplex.hpp:531
AbcSimplex::fillPerturbation
void fillPerturbation(int start, int number)
fills in perturbationSaved_ from start with 0.5+random
AbcSimplex::setClpSimplexObjectiveValue
void setClpSimplexObjectiveValue()
Sets objectiveValue_ from rawObjectiveValue_.
AbcSimplex::abcMatrix
AbcMatrix * abcMatrix() const
Abc Matrix.
Definition AbcSimplex.hpp:328
AbcSimplex::flagged
bool flagged(int sequence) const
Definition AbcSimplex.hpp:975
AbcSimplex::abcUpper_
double * abcUpper_
Working scaled copy of upper bounds has original scaled copy at end.
Definition AbcSimplex.hpp:1351
AbcSimplex::numberFlagged_
int numberFlagged_
Current number of variables flagged.
Definition AbcSimplex.hpp:1219
AbcSimplex::maximumNumberTotal_
int maximumNumberTotal_
Maximum numberTotal.
Definition AbcSimplex.hpp:1217
AbcSimplex::upper
double upper(int sequence)
Definition AbcSimplex.hpp:827
AbcSimplex::setObjectiveCoefficient
void setObjectiveCoefficient(int elementIndex, double elementValue)
Set an objective function coefficient.
AbcSimplex::checkMoveBack
void checkMoveBack(bool checkDuals)
For debug - moves solution back to external and computes stuff (always checks djs).
AbcSimplex::startFixed_
int startFixed_
Start of fixed variables.
Definition AbcSimplex.hpp:1248
AbcSimplex::numberTotalWithoutFixed_
int numberTotalWithoutFixed_
Number of variables without fixed to zero (includes spare rows).
Definition AbcSimplex.hpp:1236
AbcSimplex::reversePivotVariable_
int * reversePivotVariable_
Reverse abcPivotVariable_ for moving around.
Definition AbcSimplex.hpp:1393
AbcSimplex::abcBaseModel_
AbcSimplex * abcBaseModel_
Saved version of solution.
Definition AbcSimplex.hpp:1407
AbcSimplex::checkDjs
void checkDjs(int type=1) const
For debug - summarizes dj situation (1 recomputes duals first, 2 checks duals as well).
AbcSimplex::swapFactorization
AbcSimplexFactorization * swapFactorization(AbcSimplexFactorization *factorization)
Swaps factorization.
AbcSimplex::currentAcceptablePivot
double currentAcceptablePivot() const
Acceptable pivot for this iteration.
Definition AbcSimplex.hpp:757
AbcSimplex::setCurrentDualTolerance
void setCurrentDualTolerance(double value)
Definition AbcSimplex.hpp:278
AbcSimplex::lastFirstFree
int lastFirstFree() const
Last firstFree_.
Definition AbcSimplex.hpp:747
AbcSimplex::setPivoted
void setPivoted(int sequence)
Definition AbcSimplex.hpp:953
AbcSimplex::atFakeBound
bool atFakeBound(int sequence) const
AbcSimplex::AbcSimplex
AbcSimplex(AbcSimplex *wholeModel, int numberColumns, const int *whichColumns)
This constructor modifies original AbcSimplex and stores original stuff in created AbcSimplex.
AbcSimplex::arrayForTableauRow_
int arrayForTableauRow_
Definition AbcSimplex.hpp:1437
AbcSimplex::gutsOfSolution
int gutsOfSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements).
AbcSimplex::gutsOfDelete
void gutsOfDelete(int type)
Does most of deletion for arrays etc(0 just null arrays, 1 delete first).
AbcSimplex::gutsOfCopy
void gutsOfCopy(const AbcSimplex &rhs)
Does most of copying.
AbcSimplex::minimizationObjectiveValue
double minimizationObjectiveValue() const
Gets objective value with all offsets but as for minimization.
Definition AbcSimplex.hpp:269
AbcSimplex::gutsOfResize
void gutsOfResize(int numberRows, int numberColumns)
resizes arrays
AbcSimplex::gutsOfSolution
int gutsOfSolution(double *givenDuals, const double *givenPrimals, bool valuesPass=false)
May change basis and then returns number changed.
AbcSimplex::checkPrimalSolution
void checkPrimalSolution(bool justBasic)
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Primal).
AbcSimplex::firstFree
int firstFree() const
First Free_.
Definition AbcSimplex.hpp:742
AbcSimplex::upperRegion
double * upperRegion(int which) const
Definition AbcSimplex.hpp:623
AbcSimplex::arrayForDualColumn
int arrayForDualColumn() const
Definition AbcSimplex.hpp:514
AbcSimplex::djSaved_
double * djSaved_
Saved scaled dual solution.
Definition AbcSimplex.hpp:1373
AbcSimplex::costBasic_
double * costBasic_
Working scaled copy of basic objective.
Definition AbcSimplex.hpp:1379
AbcSimplex::tightenPrimalBounds
int tightenPrimalBounds()
Tightens primal bounds to make dual faster.
AbcSimplex::abcDualRowPivot_
AbcDualRowPivot * abcDualRowPivot_
dual row pivot choice
Definition AbcSimplex.hpp:1385
AbcSimplex::abcProgress_
AbcSimplexProgress abcProgress_
For dealing with all issues of cycling etc.
Definition AbcSimplex.hpp:1422
AbcSimplex::acceptablePivot
double acceptablePivot() const
Acceptable pivot for this iteration.
Definition AbcSimplex.hpp:293
AbcSimplex::startAtUpperNoOther_
int startAtUpperNoOther_
Start of variables at upper bound with no lower.
Definition AbcSimplex.hpp:1242
AbcSimplex::reducedCost
double reducedCost(int sequence)
Definition AbcSimplex.hpp:810
AbcSimplex::stateOfIteration_
int stateOfIteration_
Where we are in iteration.
Definition AbcSimplex.hpp:1205
AbcSimplex::freeSequenceIn
int freeSequenceIn() const
Free chosen vector.
Definition AbcSimplex.hpp:752
AbcSimplex::numberTotal
int numberTotal() const
Number of variables (includes spare rows).
Definition AbcSimplex.hpp:231
AbcSimplex::swapPrimalStuff
void swapPrimalStuff()
Swaps primal stuff.
AbcSimplex::computeInternalObjectiveValue
double computeInternalObjectiveValue()
Compute minimization objective value from internal solution without perturbation.
AbcSimplex::allSlackBasis
void allSlackBasis()
Sets up all slack basis and resets solution to as it was after initial load or readMps.
AbcSimplex::lastPivotRow
int lastPivotRow() const
Current/last pivot row (set after END of choosing pivot row in dual).
Definition AbcSimplex.hpp:737
AbcSimplex::setStateOfProblem
void setStateOfProblem(int value)
State of problem.
Definition AbcSimplex.hpp:475
AbcSimplex::permuteBasis
void permuteBasis()
deals with new basis and puts in abcPivotVariable_
AbcSimplex::fakeDjs
double * fakeDjs() const
Fake djs.
Definition AbcSimplex.hpp:658
AbcSimplex::initialSumInfeasibilities_
double initialSumInfeasibilities_
Initial sum of infeasibilities.
Definition AbcSimplex.hpp:1201
AbcSimplex::copyFromSaved
void copyFromSaved(int type=31)
Copies all saved versions to working versions and may do something for perturbation.
AbcSimplex::getSolution
int getSolution()
Given an existing factorization computes and checks primal and dual solutions.
AbcSimplex::abcDj_
double * abcDj_
Working scaled dual solution may have saved from last factorization at end.
Definition AbcSimplex.hpp:1363
AbcSimplex::lowerRegion
double * lowerRegion(int which) const
Definition AbcSimplex.hpp:619
AbcSimplex::AbcSimplexUnitTest
friend void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
AbcSimplex::setSequenceOut
void setSequenceOut(int sequence)
Definition AbcSimplex.hpp:706
AbcSimplex::setFactorizationFrequency
void setFactorizationFrequency(int value)
AbcSimplex::ordinaryVariables_
int ordinaryVariables_
Set to 1 if no free or super basic.
Definition AbcSimplex.hpp:1297
AbcSimplex::moveToBasic
void moveToBasic(int which=15)
Moves basic stuff to basic area.
AbcSimplex::maximumNumberTotal
int maximumNumberTotal() const
Maximum Total.
Definition AbcSimplex.hpp:220
AbcSimplex::gutsOfPrimalSolution
int gutsOfPrimalSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements).
AbcSimplex::getInternalColumnStatus
AbcSimplex::Status getInternalColumnStatus(int sequence) const
Definition AbcSimplex.hpp:670
AbcSimplex::fakeSuperBasic
int fakeSuperBasic(int iSequence)
Returns 1 if fake superbasic 0 if free or true superbasic -1 if was fake but has cleaned itself up (s...
Definition AbcSimplex.hpp:768
AbcSimplex::setColumnBounds
void setColumnBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
AbcSimplex::solutionRegion
double * solutionRegion(int which) const
Return region.
Definition AbcSimplex.hpp:611
AbcSimplex::perturbationBasic_
double * perturbationBasic_
basic perturbation
Definition AbcSimplex.hpp:1343
AbcSimplex::upperRegion
double * upperRegion() const
Definition AbcSimplex.hpp:602
AbcSimplex::lowerAddress
double & lowerAddress(int sequence)
Return address of row or column lower bound.
Definition AbcSimplex.hpp:823
AbcSimplex::scaleToExternal_
double * scaleToExternal_
Scale from primal internal to external (in external order) Or other way for dual.
Definition AbcSimplex.hpp:1317
AbcSimplex::sumFakeInfeasibilities_
double sumFakeInfeasibilities_
Sum of infeasibilities when using fake perturbation tolerance.
Definition AbcSimplex.hpp:1180
AbcSimplex::objectiveChange_
double objectiveChange_
Objective change.
Definition AbcSimplex.hpp:1190
AbcSimplex::costRegion
double * costRegion(int which) const
Definition AbcSimplex.hpp:627
AbcSimplex::arrayForFtran_
int arrayForFtran_
Definition AbcSimplex.hpp:1436
AbcSimplex::sequenceWithin
int sequenceWithin(int sequence) const
Returns sequence number within section.
Definition AbcSimplex.hpp:732
AbcSimplex::internalStatus
unsigned char * internalStatus() const
Definition AbcSimplex.hpp:662
AbcSimplex::cleanFactorization
int cleanFactorization(int ifValuesPass)
Get a clean factorization - i.e.
AbcSimplex::computeObjective
void computeObjective()
Computes nonbasic cost and total cost.
AbcSimplex::setupDualValuesPass
void setupDualValuesPass(const double *fakeDuals, const double *fakePrimals, int type)
Sets dual values pass djs using unscaled duals type 1 - values pass type 2 - just use as infeasibilit...
AbcSimplex::abcPerturbation_
double * abcPerturbation_
Perturbation (fixed) - is just scaled random numbers If perturbationFactor_<0 then virtual perturbati...
Definition AbcSimplex.hpp:1339
AbcSimplex::AbcSimplex
AbcSimplex(const AbcSimplex *wholeModel, int numberRows, const int *whichRows, int numberColumns, const int *whichColumns, bool dropNames=true, bool dropIntegers=true, bool fixOthers=false)
Subproblem constructor.
AbcSimplex::clpObjectiveValue
double clpObjectiveValue() const
Objective value.
Definition AbcSimplex.hpp:459
AbcSimplex::lastPrimalError_
double lastPrimalError_
Last primal error.
Definition AbcSimplex.hpp:1182
AbcSimplex::setColumnSetBounds
void setColumnSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of columns simultaneously The default implementation just invokes setColL...
AbcSimplex::defaultFactorizationFrequency
void defaultFactorizationFrequency()
If user left factorization frequency then compute.
AbcSimplex::resize
void resize(int newNumberRows, int newNumberColumns)
Resizes rim part of model.
AbcSimplex::stateDualColumn_
int stateDualColumn_
State of dual waffle -2 - in initial large tolerance phase -1 - in medium tolerance phase n - in corr...
Definition AbcSimplex.hpp:1227
AbcSimplex::movement_
double movement_
Movement of variable.
Definition AbcSimplex.hpp:1188
AbcSimplex::setFactorization
void setFactorization(AbcSimplexFactorization &factorization)
Passes in factorization.
AbcSimplex::setPrimalColumnPivotAlgorithm
void setPrimalColumnPivotAlgorithm(AbcPrimalColumnPivot &choice)
Sets column pivot choice algorithm in primal.
AbcSimplex::scaleFromExternal_
double * scaleFromExternal_
Points from external to internal.
Definition AbcSimplex.hpp:1314
AbcSimplex::originalModel
void originalModel(AbcSimplex *miniModel)
This copies back stuff from miniModel and then deletes miniModel.
AbcSimplex::numberOrdinary
int numberOrdinary() const
Number of ordinary (lo/up) in tableau row.
Definition AbcSimplex.hpp:303
AbcSimplex::setActive
void setActive(int iRow)
To say row active in primal pivot row choice.
Definition AbcSimplex.hpp:982
AbcSimplex::printStuff
void printStuff() const
Print stuff.
AbcSimplex::setDualRowPivotAlgorithm
void setDualRowPivotAlgorithm(AbcDualRowPivot &choice)
Sets row pivot choice algorithm in dual.
AbcSimplex::solutionBasic_
double * solutionBasic_
Working scaled basic primal solution.
Definition AbcSimplex.hpp:1381
AbcSimplex::setMultipleSequenceIn
void setMultipleSequenceIn(int sequenceIn[4])
set multiple sequence in
AbcSimplex::moveInfo
void moveInfo(const AbcSimplex &rhs, bool justStatus=false)
Move status and solution across.
AbcSimplex::clearPivoted
void clearPivoted(int sequence)
Definition AbcSimplex.hpp:957
AbcSimplex::checkConsistentPivots
void checkConsistentPivots() const
For debug - check pivotVariable consistent.
AbcSimplex::checkSolutionBasic
void checkSolutionBasic() const
For debug - checks solutionBasic.
AbcSimplex::checkDualSolutionPlusFake
void checkDualSolutionPlusFake()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities AND sumFake...
AbcSimplex::dualRowPivot
AbcDualRowPivot * dualRowPivot() const
dual row pivot choice
Definition AbcSimplex.hpp:318
AbcSimplex::lower
double lower(int sequence)
Definition AbcSimplex.hpp:818
AbcSimplex::lowerBasic_
double * lowerBasic_
Working scaled copy of basic lower bounds.
Definition AbcSimplex.hpp:1375
AbcSimplex::getRowPrice
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
AbcSimplex::reducedCostAddress
double & reducedCostAddress(int sequence)
Definition AbcSimplex.hpp:814
AbcSimplex::arrayForFtran
int arrayForFtran() const
Definition AbcSimplex.hpp:539
AbcSimplex::getRowActivity
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
AbcSimplex::lastPivotRow_
int lastPivotRow_
Current/last pivot row (set after END of choosing pivot row in dual).
Definition AbcSimplex.hpp:1303
AbcSimplex::multipleSequenceIn_
int multipleSequenceIn_[4]
Multiple sequence in.
Definition AbcSimplex.hpp:1428
AbcSimplex::clearArrays
void clearArrays(int which)
Clears an array and says available (-1 does all).
AbcSimplex::primal
int primal(int ifValuesPass)
Primal algorithm - see AbcSimplexPrimal.hpp for method.
AbcSimplex::offsetRhs_
double * offsetRhs_
Offset for accumulated offsets*matrix.
Definition AbcSimplex.hpp:1327
AbcSimplex::inverseColumnScale2
double * inverseColumnScale2() const
Definition AbcSimplex.hpp:506
AbcSimplex::startup
int startup(int ifValuesPass)
Common bits of coding for dual and primal.
AbcSimplex::saveData_
ClpDataSave saveData_
For saving stuff at beginning.
Definition AbcSimplex.hpp:1424
AbcSimplex::setColBounds
void setColBounds(int elementIndex, double newlower, double newupper)
Set a single column lower and upper bound.
Definition AbcSimplex.hpp:1107
AbcSimplex::freeSequenceIn_
int freeSequenceIn_
Free chosen vector.
Definition AbcSimplex.hpp:1211
AbcSimplex::getAvailableArrayPublic
int getAvailableArrayPublic() const
Returns first available empty array (and sets flag) when no possibility of going parallel.
Definition AbcSimplex.hpp:881
AbcSimplex::abcLower_
double * abcLower_
Working scaled copy of lower bounds has original scaled copy at end.
Definition AbcSimplex.hpp:1348
AbcSimplex::restoreData
void restoreData(ClpDataSave saved)
Restore data.
AbcSimplex::currentAcceptablePivot_
double currentAcceptablePivot_
Acceptable pivot for this iteration.
Definition AbcSimplex.hpp:1186
AbcSimplex::unpack
void unpack(CoinIndexedVector &rowArray, int sequence) const
Unpacks one column of the matrix into indexed array.
AbcSimplex::pivoted
bool pivoted(int sequence) const
Definition AbcSimplex.hpp:961
AbcSimplex::getReducedCost
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
AbcSimplex::solution
double solution(int sequence)
Return row or column values.
Definition AbcSimplex.hpp:801
AbcSimplex::arrayForFlipBounds
int arrayForFlipBounds() const
Definition AbcSimplex.hpp:527
AbcSimplex::checkDualSolution
void checkDualSolution()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Dual).
AbcSimplex::setInternalColumnStatus
void setInternalColumnStatus(int sequence, AbcSimplex::Status newstatus)
Definition AbcSimplex.hpp:680
AbcSimplex::clearFlagged
void clearFlagged(int sequence)
Definition AbcSimplex.hpp:971
AbcSimplex::getAvailableArray
int getAvailableArray() const
Returns first available empty array (and sets flag).
AbcSimplex::sequenceIn
int sequenceIn() const
Return sequence In or Out.
Definition AbcSimplex.hpp:693
AbcSimplex::internalFactorize
int internalFactorize(int solveType)
Factorizes using current basis.
AbcSimplex::moveStatusFromClp
void moveStatusFromClp(ClpSimplex *clpModel)
Move status and solution from ClpSimplex.
AbcSimplex::putStuffInBasis
void putStuffInBasis(int type)
Puts more stuff in basis 1 bit set - do even if basis exists 2 bit set - don't bother staying triangu...
AbcSimplex::solutionAddress
double & solutionAddress(int sequence)
Return address of row or column values.
Definition AbcSimplex.hpp:806
AbcSimplex::makeBaseModel
void makeBaseModel()
Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 bu...
AbcSimplex::abcFactorization_
AbcSimplexFactorization * abcFactorization_
factorization
Definition AbcSimplex.hpp:1395
AbcSimplex::AbcSimplex
AbcSimplex(bool emptyMessages=false)
Default constructor.
AbcSimplex::costRegion
double * costRegion() const
Definition AbcSimplex.hpp:606
AbcSimplex::AbcSimplex
AbcSimplex(const ClpSimplex &rhs)
Copy constructor from model.
AbcSimplex::primalColumnPivot
AbcPrimalColumnPivot * primalColumnPivot() const
primal column pivot choice
Definition AbcSimplex.hpp:323
AbcSimplex::btranAlpha_
double btranAlpha_
Btran alpha.
Definition AbcSimplex.hpp:1192
AbcSimplex::unpack
void unpack(CoinIndexedVector &rowArray) const
Unpacks one column of the matrix into indexed array Uses sequenceIn_.
Definition AbcSimplex.hpp:381
AbcSimplex::scaleToExternal
double * scaleToExternal() const
Scale from primal internal to external (in external order) Or other way for dual.
Definition AbcSimplex.hpp:493
AbcSimplex::setInternalStatus
void setInternalStatus(int sequence, AbcSimplex::Status newstatus)
Definition AbcSimplex.hpp:674
AbcSimplex::inverseColumnUseScale_
double * inverseColumnUseScale_
use this instead of inverseColumnScale
Definition AbcSimplex.hpp:1321
AbcSimplex::costAddress
double & costAddress(int sequence)
Return address of row or column cost.
Definition AbcSimplex.hpp:841
AbcSimplex::startAtUpperOther_
int startAtUpperOther_
Start of variables at upper bound with lower.
Definition AbcSimplex.hpp:1244
AbcSimplex::startAtLowerOther_
int startAtLowerOther_
Start of variables at lower bound with upper.
Definition AbcSimplex.hpp:1240
AbcSimplex::setRowLower
void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -DBL_MAX for -infinity.
AbcSimplex::valueIncomingDual
double valueIncomingDual() const
value of incoming variable (in Dual)
AbcSimplex::setColLower
void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
Definition AbcSimplex.hpp:1095
AbcSimplex::upperAddress
double & upperAddress(int sequence)
Return address of row or column upper bound.
Definition AbcSimplex.hpp:832
AbcSimplex::setToBaseModel
void setToBaseModel(AbcSimplex *model=NULL)
Reset to base model (just size and arrays needed) If model NULL use internal copy.
AbcSimplex::setUsedArray
void setUsedArray(int which) const
Say array going to be used.
Definition AbcSimplex.hpp:917
AbcSimplex::currentDualTolerance_
double currentDualTolerance_
Current dualTolerance (will end up as dualTolerance_).
Definition AbcSimplex.hpp:1172
AbcSimplex::getColSolution
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
AbcSimplex::saveGoodStatus
void saveGoodStatus()
Saves good status etc.
AbcSimplex::initialDenseFactorization
bool initialDenseFactorization() const
AbcSimplex::djBasic
double * djBasic() const
Definition AbcSimplex.hpp:636
AbcSimplex::putBackSolution
void putBackSolution(ClpSimplex *simplex)
Put back solution into ClpSimplex.
AbcSimplex::numberFreeNonBasic_
int numberFreeNonBasic_
Number of free nonbasic variables.
Definition AbcSimplex.hpp:1299
AbcSimplex::maximumAbcNumberRows_
int maximumAbcNumberRows_
Maximum number rows.
Definition AbcSimplex.hpp:1213
AbcSimplex::internalStatusSaved_
unsigned char * internalStatusSaved_
Saved status.
Definition AbcSimplex.hpp:1336
AbcSimplex::setupPointers
void setupPointers(int maxRows, int maxColumns)
Sets up all extra pointers.
AbcSimplex::clearArraysPublic
void clearArraysPublic(int which)
Clears an array and says available (-1 does all) when no possibility of going parallel.
Definition AbcSimplex.hpp:875
AbcSimplex::setAvailableArray
void setAvailableArray(int which) const
Say array going available.
Definition AbcSimplex.hpp:924
AbcSimplex::costBasic
double * costBasic() const
Definition AbcSimplex.hpp:648
AbcSimplex::pivotVariable
int * pivotVariable() const
Basic variables pivoting on which rows may be same as toExternal but may be as at invert.
Definition AbcSimplex.hpp:465
AbcSimplex::perturbationFactor_
double perturbationFactor_
Perturbation factor If <0.0 then virtual if 0.0 none if >0.0 use this as factor.
Definition AbcSimplex.hpp:1170
AbcSimplex::setColumnLower
void setColumnLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
AbcSimplex::checkBothSolutions
void checkBothSolutions()
This sets sum and number of infeasibilities (Dual and Primal).
AbcSimplex::sequenceOut
int sequenceOut() const
Definition AbcSimplex.hpp:697
AbcSimplex::abcPivotVariable_
int * abcPivotVariable_
Basic variables pivoting on which rows followed by atLo/atUp then free/superbasic then fixed.
Definition AbcSimplex.hpp:1391
AbcSimplex::ordinaryVariables
int ordinaryVariables() const
Set to 1 if no free or super basic.
Definition AbcSimplex.hpp:298
AbcSimplex::AbcSimplex
AbcSimplex(const ClpSimplex *clpSimplex)
This constructor copies from ClpSimplex.
AbcSimplex::currentDualBound_
double currentDualBound_
Current dualBound (will end up as dualBound_).
Definition AbcSimplex.hpp:1174
AbcSimplex::setColSetBounds
void setColSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of columns simultaneously .
Definition AbcSimplex.hpp:1119
AbcSimplex::AbcSimplex
AbcSimplex(const ClpSimplex *wholeModel, int numberRows, const int *whichRows, int numberColumns, const int *whichColumns, bool dropNames=true, bool dropIntegers=true, bool fixOthers=false)
Subproblem constructor.
AbcSimplex::lastFirstFree_
int lastFirstFree_
Last firstFree_.
Definition AbcSimplex.hpp:1209
AbcSimplex::maximumAbcNumberColumns_
int maximumAbcNumberColumns_
Maximum number columns.
Definition AbcSimplex.hpp:1215
AbcSimplex::numberFlipped_
int numberFlipped_
Definition AbcSimplex.hpp:1439
AbcSimplex::cost
double cost(int sequence)
Definition AbcSimplex.hpp:836
AbcSimplex::arrayForDualColumn_
int arrayForDualColumn_
Definition AbcSimplex.hpp:1431
AbcSimplex::dual
int dual()
Dual algorithm - see AbcSimplexDual.hpp for method.
AbcSimplex::translate
void translate(int type)
Translates ClpModel to AbcSimplex See DO_ bits in stateOfProblem_ for type e.g.
AbcSimplex::setColumnUpper
void setColumnUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
AbcSimplex::arrayForReplaceColumn_
int arrayForReplaceColumn_
Definition AbcSimplex.hpp:1432
AbcSimplex::ftAlpha_
double ftAlpha_
FT alpha.
Definition AbcSimplex.hpp:1197
AbcSimplex::minimumThetaMovement_
double minimumThetaMovement_
Minimum theta movement.
Definition AbcSimplex.hpp:1199
AbcSimplex::setRowSetBounds
void setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of rows simultaneously .
AbcSimplex::upperSaved_
double * upperSaved_
Saved scaled copy of upper bounds.
Definition AbcSimplex.hpp:1367
AbcSimplex::perturbationSaved
double * perturbationSaved() const
Perturbation (fixed) - is just scaled random numbers.
Definition AbcSimplex.hpp:288
AbcSimplex::swapDualStuff
void swapDualStuff(int lastSequenceOut, int lastDirectionOut)
Swaps dual stuff.
AbcSimplex::numberOrdinary_
int numberOrdinary_
Number of ordinary (lo/up) in tableau row.
Definition AbcSimplex.hpp:1295
AbcSimplex::abcProgress
AbcSimplexProgress * abcProgress()
For dealing with all issues of cycling etc.
Definition AbcSimplex.hpp:862
AbcSimplex::setObjCoeff
void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
Definition AbcSimplex.hpp:1064
AbcSimplex::usefulArray
CoinPartitionedVector * usefulArray(int index)
Useful arrays (0,1,2,3,4,5,6,7).
Definition AbcSimplex.hpp:241
AbcSimplex::swap
void swap(int pivotRow, int nonBasicPosition)
Swaps two variables.
AbcSimplex::djRegion
double * djRegion(int which) const
Definition AbcSimplex.hpp:615
AbcSimplex::usefulArray_
CoinPartitionedVector usefulArray_[ABC_NUMBER_USEFUL]
Definition AbcSimplex.hpp:1420
AbcSimplex::arrayForTableauRow
int arrayForTableauRow() const
Definition AbcSimplex.hpp:543
AbcSimplex::cleanStatus
void cleanStatus(bool valuesPass=false)
Clean up status - make sure no superbasic etc.
AbcSimplex::isObjectiveLimitTestValid
bool isObjectiveLimitTestValid() const
Return true if the objective limit test can be relied upon.
AbcSimplex::numberTotal_
int numberTotal_
Number of variables (includes spare rows).
Definition AbcSimplex.hpp:1234
AbcSimplex::abcCost_
double * abcCost_
Working scaled copy of objective ?
Definition AbcSimplex.hpp:1357
AbcSimplex::computeObjectiveValue
void computeObjectiveValue(bool useWorkingSolution=false)
Compute objective value from solution and put in objectiveValue_.
AbcSimplex::setNumberOrdinary
void setNumberOrdinary(int number)
Set number of ordinary (lo/up) in tableau row.
Definition AbcSimplex.hpp:308
AbcSimplex::isColumn
int isColumn(int sequence) const
Returns 1 if sequence indicates column.
Definition AbcSimplex.hpp:727
AbcSimplex::computePrimals
int computePrimals(CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes primals from scratch. Returns number of refinements.
AbcSimplex::clearArrays
void clearArrays(CoinPartitionedVector *which)
Clears an array and says available.
AbcSimplex::setColUpper
void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
Definition AbcSimplex.hpp:1101
AbcSimplex::solutionBasic
double * solutionBasic() const
Return region.
Definition AbcSimplex.hpp:632
AbcSimplex::getEmptyFactorization
AbcSimplexFactorization * getEmptyFactorization()
Gets clean and emptyish factorization.
AbcSimplex::doAbcDual
int doAbcDual()
AbcSimplex::refreshUpper
void refreshUpper(unsigned int type=~(ROW_LOWER_SAME|COLUMN_LOWER_SAME))
AbcSimplex::tempArray_
double * tempArray_
Useful array of numberTotal length.
Definition AbcSimplex.hpp:1329
AbcSimplex::columnScale2
double * columnScale2() const
Definition AbcSimplex.hpp:510
AbcSimplex::numberTotalWithoutFixed
int numberTotalWithoutFixed() const
Number of variables without fixed to zero (includes spare rows).
Definition AbcSimplex.hpp:236
AbcSimplex::djRegion
double * djRegion() const
Definition AbcSimplex.hpp:594
AbcSimplex::internalStatus_
unsigned char * internalStatus_
Working status ?
Definition AbcSimplex.hpp:1334
AbcSimplex::columnUseScale_
double * columnUseScale_
use this instead of columnScale
Definition AbcSimplex.hpp:1319
AbcSimplex::lowerBasic
double * lowerBasic() const
Definition AbcSimplex.hpp:640
AbcSimplex::lowerRegion
double * lowerRegion() const
Definition AbcSimplex.hpp:598
AbcSimplex::getBasis
CoinWarmStartBasis * getBasis() const
Returns a basis (to be deleted by user).
AbcSimplex::factorization
AbcSimplexFactorization * factorization() const
factorization
Definition AbcSimplex.hpp:200
AbcSimplex::abcNonLinearCost_
AbcNonLinearCost * abcNonLinearCost_
Very wasteful way of dealing with infeasibilities in primal.
Definition AbcSimplex.hpp:1414
AbcSimplex::permuteOut
void permuteOut(int whatsWanted)
Permutes out - bit settings same as stateOfProblem.
AbcSimplex::swap
void swap(int pivotRow, int nonBasicPosition, Status newStatus)
Swaps two variables and does status.
AbcSimplex::clpModel_
ClpSimplex * clpModel_
A copy of model as ClpSimplex with certain state.
Definition AbcSimplex.hpp:1409
AbcSimplex::setRowBounds
void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
AbcSimplex::originalUpper
double originalUpper(int iSequence) const
Return original lower bound.
Definition AbcSimplex.hpp:854
AbcSimplex::upperTheta_
double upperTheta_
upper theta from dual column
Definition AbcSimplex.hpp:1426
AbcSimplex::upperBasic
double * upperBasic() const
Definition AbcSimplex.hpp:644
AbcSimplex::doAbcPrimal
int doAbcPrimal(int ifValuesPass)
AbcSimplex::abcNonLinearCost
AbcNonLinearCost * abcNonLinearCost() const
Return pointer to details of costs.
Definition AbcSimplex.hpp:283
AbcSimplex::getFakeBound
FakeBound getFakeBound(int sequence) const
Definition AbcSimplex.hpp:948
AbcSimplex::offset_
double * offset_
Primal offset (in external order) So internal value is (external-offset)*scaleFromExternal.
Definition AbcSimplex.hpp:1325
AbcSimplex::baseModel
AbcSimplex * baseModel() const
See if we have base model.
Definition AbcSimplex.hpp:146
AbcSimplex::arrayForFlipBounds_
int arrayForFlipBounds_
Definition AbcSimplex.hpp:1433
AbcSimplex::stateOfProblem
int stateOfProblem() const
State of problem.
Definition AbcSimplex.hpp:470
AbcSimplex::objectiveOffset_
double objectiveOffset_
Objective offset (from offset_).
Definition AbcSimplex.hpp:1165
AbcSimplex::arrayForReplaceColumn
int arrayForReplaceColumn() const
Definition AbcSimplex.hpp:523
AbcSimplex::rowScale2
double * rowScale2() const
corresponds to rowScale etc
Definition AbcSimplex.hpp:498
AbcSimplex::refreshCosts
void refreshCosts()
After modifying first copy refreshes second copy and marks as updated.
AbcSimplex::scaleFromExternal
double * scaleFromExternal() const
Points from external to internal.
Definition AbcSimplex.hpp:487
AbcSimplex::lastDualBound_
double lastDualBound_
Last dual bound.
Definition AbcSimplex.hpp:1178
AbcSimplex::currentDualBound
double currentDualBound() const
Current dualBound (will end up as dualBound_).
Definition AbcSimplex.hpp:313
AbcSimplex::arrayForFlipRhs_
int arrayForFlipRhs_
Definition AbcSimplex.hpp:1434
AbcSimplex::operator=
AbcSimplex & operator=(const AbcSimplex &rhs)
Assignment operator. This copies the data.
AbcSimplex::currentDualTolerance
double currentDualTolerance() const
Current dualTolerance (will end up as dualTolerance_).
Definition AbcSimplex.hpp:274
AbcSimplex::Status
Status
enums for status of various sorts.
Definition AbcSimplex.hpp:74
AbcSimplex::atUpperBound
@ atUpperBound
Definition AbcSimplex.hpp:76
AbcSimplex::isFree
@ isFree
Definition AbcSimplex.hpp:77
AbcSimplex::isFixed
@ isFixed
Definition AbcSimplex.hpp:80
AbcSimplex::atLowerBound
@ atLowerBound
Definition AbcSimplex.hpp:75
AbcSimplex::superBasic
@ superBasic
Definition AbcSimplex.hpp:78
AbcSimplex::basic
@ basic
Definition AbcSimplex.hpp:79
AbcSimplex::setInitialDenseFactorization
void setInitialDenseFactorization(bool onOff)
Normally the first factorization does sparse coding because the factorization could be singular.
AbcSimplex::clearActive
void clearActive(int iRow)
Definition AbcSimplex.hpp:986
AbcSimplex::sumNonBasicCosts_
double sumNonBasicCosts_
Sum of nonbasic costs.
Definition AbcSimplex.hpp:1161
AbcSimplex::setSequenceIn
void setSequenceIn(int sequence)
Set sequenceIn or Out.
Definition AbcSimplex.hpp:702
AbcSimplex::arrayForBtran
int arrayForBtran() const
Definition AbcSimplex.hpp:535
AbcSimplex::arrayForBtran_
int arrayForBtran_
Definition AbcSimplex.hpp:1435
AbcSimplex::originalLower
double originalLower(int iSequence) const
Return original lower bound.
Definition AbcSimplex.hpp:846
AbcSimplex::active
bool active(int iRow) const
Definition AbcSimplex.hpp:990
AbcSimplex::numberDisasters_
int numberDisasters_
Definition AbcSimplex.hpp:1440
AbcSimplex::upperBasic_
double * upperBasic_
Working scaled copy of basic upper bounds.
Definition AbcSimplex.hpp:1377
AbcSimplex::maximumAbcNumberRows
int maximumAbcNumberRows() const
Maximum rows.
Definition AbcSimplex.hpp:215
AbcSimplex::abcMatrix_
AbcMatrix * abcMatrix_
Working matrix.
Definition AbcSimplex.hpp:1345
AbcSimplex::lastDualError_
double lastDualError_
Last dual error.
Definition AbcSimplex.hpp:1184
AbcSimplex::solutionSaved_
double * solutionSaved_
Saved scaled primal solution.
Definition AbcSimplex.hpp:1371
AbcSimplex::inverseRowScale2
double * inverseRowScale2() const
Definition AbcSimplex.hpp:502
AbcSimplex::computeDuals
int computeDuals(double *givenDjs, CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes duals from scratch.
AbcSimplex::gutsOfInitialize
void gutsOfInitialize(int numberRows, int numberColumns, bool doMore)
Initializes arrays.
AbcSimplex::crash
void crash(int type)
Does sort of crash.
AbcSimplex::solutionRegion
double * solutionRegion() const
Return region.
Definition AbcSimplex.hpp:590
AbcSimplex::createStatus
void createStatus()
Set up status array (can be used by OsiAbc).
AbcSimplex::usefulArray
CoinPartitionedVector * usefulArray(int index) const
Definition AbcSimplex.hpp:245
AbcSimplex::djBasic_
double * djBasic_
Working scaled basic dual solution (want it to be zero).
Definition AbcSimplex.hpp:1383
AbcSimplex::saveData
ClpDataSave saveData()
Save data.
AbcSimplex::stateOfProblem_
int stateOfProblem_
Definition AbcSimplex.hpp:1286
AbcSimplex::refreshLower
void refreshLower(unsigned int type=~(ROW_LOWER_SAME|COLUMN_UPPER_SAME))
AbcSimplex::setRowUpper
void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use DBL_MAX for infinity.
AbcSimplex::abcSolution_
double * abcSolution_
Working scaled primal solution may have saved from last factorization at end.
Definition AbcSimplex.hpp:1360
AbcSimplex::maximumTotal
int maximumTotal() const
Definition AbcSimplex.hpp:224
AbcSimplex::deleteBaseModel
void deleteBaseModel()
Switch off base model.
AbcSimplex::rawObjectiveValue
double rawObjectiveValue() const
Raw objective value (so always minimize in primal).
Definition AbcSimplex.hpp:1017
AbcSimplex::upperTheta
double upperTheta() const
upper theta from dual column
Definition AbcSimplex.hpp:519
AbcSimplex::lowerSaved_
double * lowerSaved_
Saved scaled copy of lower bounds.
Definition AbcSimplex.hpp:1365
AbcSimplex::~AbcSimplex
~AbcSimplex()
Destructor.
AbcSimplex::abcPrimalColumnPivot_
AbcPrimalColumnPivot * abcPrimalColumnPivot_
primal column pivot choice
Definition AbcSimplex.hpp:1387
AbcSimplex::lastCleaned_
int lastCleaned_
Last time cleaned up.
Definition AbcSimplex.hpp:1301
AbcSimplex::permuteIn
void permuteIn()
Permutes in from ClpModel data - assumes scale factors done and AbcMatrix exists but is in original o...
AbcSimplex::factorizationFrequency
int factorizationFrequency() const
Factorization frequency.
AbcSimplex::perturbationSaved_
double * perturbationSaved_
saved perturbation
Definition AbcSimplex.hpp:1341
AbcSimplex::swappedAlgorithm_
int swappedAlgorithm_
Nonzero (probably 10) if swapped algorithms.
Definition AbcSimplex.hpp:1305
AbcSimplex::FakeBound
FakeBound
Definition AbcSimplex.hpp:83
AbcSimplex::noFake
@ noFake
Definition AbcSimplex.hpp:84
AbcSimplex::bothFake
@ bothFake
Definition AbcSimplex.hpp:87
AbcSimplex::lowerFake
@ lowerFake
Definition AbcSimplex.hpp:85
AbcSimplex::upperFake
@ upperFake
Definition AbcSimplex.hpp:86
AbcSimplex::getInternalStatus
AbcSimplex::Status getInternalStatus(int sequence) const
Definition AbcSimplex.hpp:666
AbcSimplex::rawObjectiveValue_
double rawObjectiveValue_
Sum of costs (raw objective value).
Definition AbcSimplex.hpp:1163
AbcSimplex::setFlagged
void setFlagged(int sequence)
To flag a variable.
AbcTolerancesEtc
Definition CoinAbcCommon.hpp:254
ClpDataSave
This is a tiny class where data can be saved round calls.
Definition ClpModel.hpp:1402
ClpDisasterHandler
Base class for Clp disaster handling.
Definition ClpEventHandler.hpp:138
ClpModel::numberColumns_
int numberColumns_
Number of columns.
Definition ClpModel.hpp:1259
ClpModel::getNumElements
CoinBigIndex getNumElements() const
Number of elements in matrix.
Definition ClpModel.hpp:781
ClpModel::optimizationDirection_
double optimizationDirection_
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition ClpModel.hpp:1245
ClpModel::rowUpper_
double * rowUpper_
Row upper.
Definition ClpModel.hpp:1271
ClpModel::rowLower_
double * rowLower_
Row lower.
Definition ClpModel.hpp:1269
ClpModel::columnUpper_
double * columnUpper_
Column Upper.
Definition ClpModel.hpp:1279
ClpModel::dblParam_
double dblParam_[ClpLastDblParam]
Array of double parameters.
Definition ClpModel.hpp:1247
ClpModel::numberColumns
int numberColumns() const
Definition ClpModel.hpp:332
ClpModel::numberRows
int numberRows() const
Number of rows.
Definition ClpModel.hpp:319
ClpModel::objectiveValue_
double objectiveValue_
Objective value.
Definition ClpModel.hpp:1249
ClpModel::solveType
int solveType() const
Solve type - 1 simplex, 2 simplex interface, 3 Interior.
Definition ClpModel.hpp:391
ClpModel::columnLower_
double * columnLower_
Column Lower.
Definition ClpModel.hpp:1277
ClpModel::dropNames
void dropNames()
Drops names - makes lengthnames 0 and names empty.
ClpSimplex::primalTolerance_
double primalTolerance_
Current primal tolerance for algorithm.
Definition ClpSimplex.hpp:1802
ClpSimplex::bestPossibleImprovement_
double bestPossibleImprovement_
Best possible improvement using djs (primal) or obj change by flipping bounds to make dual feasible (...
Definition ClpSimplex.hpp:1752
ClpSimplex::pivotRow
int pivotRow() const
Pivot Row for use by classes e.g. steepestedge.
Definition ClpSimplex.hpp:1080
ClpSimplex::acceptablePivot_
double acceptablePivot_
Acceptable pivot value just after factorization.
Definition ClpSimplex.hpp:1814
ClpSimplex::sequenceOut_
int sequenceOut_
Sequence of Out variable.
Definition ClpSimplex.hpp:1847
ClpSimplex::rowArray
CoinIndexedVector * rowArray(int index) const
Useful row length arrays (0,1,2,3,4,5).
Definition ClpSimplex.hpp:815
ClpSimplex::sequenceIn_
int sequenceIn_
Sequence of In variable.
Definition ClpSimplex.hpp:1843
ClpSimplex::ClpSimplex
ClpSimplex(bool emptyMessages=false)
Default constructor.
ClpSimplex::firstFree_
int firstFree_
First free/super-basic variable (-1 if none).
Definition ClpSimplex.hpp:1921