ClpSimplexDual.hpp

Go to the documentation of this file.

/* $Id: ClpSimplexDual.hpp 1761 2011-07-06 16:06:24Z forrest $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
/*
   Authors
 
   John Forrest
 
 */
#ifndef ClpSimplexDual_H
#define ClpSimplexDual_H
 
#include "ClpSimplex.hpp"
 
class ClpSimplexDual : public ClpSimplex {
 
public:
 
     int dual(int ifValuesPass, int startFinishOptions = 0);
     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);
     ClpFactorization * setupForStrongBranching(char * arrays, int numberRows,
               int numberColumns, bool solveLp = false);
     void cleanupAfterStrongBranching(ClpFactorization * factorization);
 
     int whileIterating(double * & givenPi, int ifValuesPass);
     int updateDualsInDual(CoinIndexedVector * rowArray,
                           CoinIndexedVector * columnArray,
                           CoinIndexedVector * outputArray,
                           double theta,
                           double & objectiveChange,
                           bool fullRecompute);
     void updateDualsInValuesPass(CoinIndexedVector * rowArray,
                                  CoinIndexedVector * columnArray,
                                  double theta);
     void flipBounds(CoinIndexedVector * rowArray,
                     CoinIndexedVector * columnArray);
     double dualColumn(CoinIndexedVector * rowArray,
                       CoinIndexedVector * columnArray,
                       CoinIndexedVector * spareArray,
                       CoinIndexedVector * spareArray2,
                       double accpetablePivot,
                       CoinBigIndex * dubiousWeights);
     int dualColumn0(const CoinIndexedVector * rowArray,
                     const CoinIndexedVector * columnArray,
                     CoinIndexedVector * spareArray,
                     double acceptablePivot,
                     double & upperReturn, double &bestReturn, double & badFree);
     void checkPossibleValuesMove(CoinIndexedVector * rowArray,
                                  CoinIndexedVector * columnArray,
                                  double acceptablePivot);
     void checkPossibleCleanup(CoinIndexedVector * rowArray,
                               CoinIndexedVector * columnArray,
                               double acceptablePivot);
     void doEasyOnesInValuesPass(double * givenReducedCosts);
     void dualRow(int alreadyChosen);
     int changeBounds(int initialize, CoinIndexedVector * outputArray,
                      double & changeCost);
     bool changeBound( int iSequence);
     void originalBound(int iSequence);
     int checkUnbounded(CoinIndexedVector * ray, CoinIndexedVector * spare,
                        double changeCost);
     void statusOfProblemInDual(int & lastCleaned, int type,
                                double * givenDjs, ClpDataSave & saveData,
                                int ifValuesPass);
     int perturb();
     int fastDual(bool alwaysFinish = false);
     int numberAtFakeBound();
 
     int pivotResultPart1();
     int nextSuperBasic();
     int startupSolve(int ifValuesPass, double * saveDuals, int startFinishOptions);
     void finishSolve(int startFinishOptions);
     void gutsOfDual(int ifValuesPass, double * & saveDuals, int initialStatus,
                     ClpDataSave & saveData);
     //int dual2(int ifValuesPass,int startFinishOptions=0);
     void resetFakeBounds(int type);
 
};
#endif