Cbc  2.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Go to the documentation of this file.
1 /* $Id: ClpSimplexDual.hpp 1761 2011-07-06 16:06:24Z forrest $ */
2 // Copyright (C) 2002, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 /*
6  Authors
8  John Forrest
10  */
11 #ifndef ClpSimplexDual_H
12 #define ClpSimplexDual_H
14 #include "ClpSimplex.hpp"
23 class ClpSimplexDual : public ClpSimplex {
25 public:
118  int dual(int ifValuesPass, int startFinishOptions = 0);
127  int strongBranching(int numberVariables, const int * variables,
128  double * newLower, double * newUpper,
129  double ** outputSolution,
130  int * outputStatus, int * outputIterations,
131  bool stopOnFirstInfeasible = true,
132  bool alwaysFinish = false,
133  int startFinishOptions = 0);
136  int numberColumns, bool solveLp = false);
156  int whileIterating(double * & givenPi, int ifValuesPass);
166  CoinIndexedVector * outputArray,
167  double theta,
168  double & objectiveChange,
169  bool fullRecompute);
174  CoinIndexedVector * columnArray,
175  double theta);
179  void flipBounds(CoinIndexedVector * rowArray,
180  CoinIndexedVector * columnArray);
192  double dualColumn(CoinIndexedVector * rowArray,
193  CoinIndexedVector * columnArray,
194  CoinIndexedVector * spareArray,
195  CoinIndexedVector * spareArray2,
196  double accpetablePivot,
197  CoinBigIndex * dubiousWeights);
199  int dualColumn0(const CoinIndexedVector * rowArray,
200  const CoinIndexedVector * columnArray,
201  CoinIndexedVector * spareArray,
202  double acceptablePivot,
203  double & upperReturn, double &bestReturn, double & badFree);
211  CoinIndexedVector * columnArray,
212  double acceptablePivot);
219  void checkPossibleCleanup(CoinIndexedVector * rowArray,
220  CoinIndexedVector * columnArray,
221  double acceptablePivot);
226  void doEasyOnesInValuesPass(double * givenReducedCosts);
236  void dualRow(int alreadyChosen);
246  int changeBounds(int initialize, CoinIndexedVector * outputArray,
247  double & changeCost);
250  bool changeBound( int iSequence);
252  void originalBound(int iSequence);
256  double changeCost);
266  void statusOfProblemInDual(int & lastCleaned, int type,
267  double * givenDjs, ClpDataSave & saveData,
268  int ifValuesPass);
271  int perturb();
277  int fastDual(bool alwaysFinish = false);
280  int numberAtFakeBound();
286  int pivotResultPart1();
288  int nextSuperBasic();
291  int startupSolve(int ifValuesPass, double * saveDuals, int startFinishOptions);
292  void finishSolve(int startFinishOptions);
293  void gutsOfDual(int ifValuesPass, double * & saveDuals, int initialStatus,
294  ClpDataSave & saveData);
295  //int dual2(int ifValuesPass,int startFinishOptions=0);
296  void resetFakeBounds(int type);
299 };
300 #endif
double * ray() const
For advanced users - no need to delete - sign not changed.
Definition: ClpModel.hpp:772
int numberAtFakeBound()
Checks number of variables at fake bounds.
int checkUnbounded(CoinIndexedVector *ray, CoinIndexedVector *spare, double changeCost)
Checks if tentative optimal actually means unbounded in dual Returns -3 if not, 2 if is unbounded...
int fastDual(bool alwaysFinish=false)
Fast iterations.
int startupSolve(int ifValuesPass, double *saveDuals, int startFinishOptions)
Startup part of dual (may be extended to other algorithms) returns 0 if good, 1 if bad...
ClpFactorization * setupForStrongBranching(char *arrays, int numberRows, int numberColumns, bool solveLp=false)
This does first part of StrongBranching.
bool changeBound(int iSequence)
As changeBounds but just changes new bounds for a single variable.
double theta() const
Theta (pivot change)
int changeBounds(int initialize, CoinIndexedVector *outputArray, double &changeCost)
Checks if any fake bounds active - if so returns number and modifies updatedDualBound_ and everything...
void gutsOfDual(int ifValuesPass, double *&saveDuals, int initialStatus, ClpDataSave &saveData)
void statusOfProblemInDual(int &lastCleaned, int type, double *givenDjs, ClpDataSave &saveData, int ifValuesPass)
Refactorizes if necessary Checks if finished.
void cleanupAfterStrongBranching(ClpFactorization *factorization)
This cleans up after strong branching.
This just implements CoinFactorization when an ClpMatrixBase object is passed.
void checkPossibleCleanup(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray, double acceptablePivot)
Row array has row part of pivot row Column array has column part.
int pivotResultPart1()
Pivot in a variable and choose an outgoing one.
int numberColumns() const
Definition: ClpModel.hpp:325
void dualRow(int alreadyChosen)
Chooses dual pivot row Would be faster with separate region to scan and will have this (with square o...
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)
For strong branching.
double dualColumn(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray, CoinIndexedVector *spareArray, CoinIndexedVector *spareArray2, double accpetablePivot, CoinBigIndex *dubiousWeights)
Row array has row part of pivot row Column array has column part.
int perturb()
Perturbs problem (method depends on perturbation()) returns nonzero if should go to dual...
int dual(int ifValuesPass, int startFinishOptions=0)
Dual algorithm.
This solves LPs using the simplex method.
Definition: ClpSimplex.hpp:70
int updateDualsInDual(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray, CoinIndexedVector *outputArray, double theta, double &objectiveChange, bool fullRecompute)
The duals are updated by the given arrays.
Indexed Vector.
void checkPossibleValuesMove(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray, double acceptablePivot)
Row array has row part of pivot row Column array has column part.
void doEasyOnesInValuesPass(double *givenReducedCosts)
This sees if we can move duals in dual values pass.
void finishSolve(int startFinishOptions)
void flipBounds(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray)
While updateDualsInDual sees what effect is of flip this does actual flipping.
This is a tiny class where data can be saved round calls.
Definition: ClpModel.hpp:1269
CoinIndexedVector * columnArray(int index) const
Useful column length arrays (0,1,2,3,4,5)
Definition: ClpSimplex.hpp:731
void originalBound(int iSequence)
Restores bound to original bound.
void resetFakeBounds(int type)
int numberRows() const
Number of rows.
Definition: ClpModel.hpp:315
int CoinBigIndex
void updateDualsInValuesPass(CoinIndexedVector *rowArray, CoinIndexedVector *columnArray, double theta)
The duals are updated by the given arrays.
ClpFactorization * factorization() const
Definition: ClpSimplex.hpp:607
int nextSuperBasic()
Get next free , -1 if none.
CoinIndexedVector * rowArray(int index) const
Useful row length arrays (0,1,2,3,4,5)
Definition: ClpSimplex.hpp:727
ClpDataSave saveData()
Save data.
This solves LPs using the dual simplex method.
int dualColumn0(const CoinIndexedVector *rowArray, const CoinIndexedVector *columnArray, CoinIndexedVector *spareArray, double acceptablePivot, double &upperReturn, double &bestReturn, double &badFree)
Does first bit of dualColumn.
int whileIterating(double *&givenPi, int ifValuesPass)
This has the flow between re-factorizations Broken out for clarity and will be used by strong branchi...