Clp/Doxygen/ClpSimplexDual_8hpp_source.html

/* $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 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 &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);

  int checkFakeBounds() const;

  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


/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2

*/