Clp/Doxygen/AbcSimplexDual_8hpp_source.html

/* $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 AbcSimplexDual_H

#define AbcSimplexDual_H


#include "AbcSimplex.hpp"

#if 0

#undef ABC_PARALLEL

#define ABC_PARALLEL 2

#undef cilk_for

#undef cilk_spawn

#undef cilk_sync

#include <cilk/cilk.h>

#endif

typedef struct {

  double theta;

  double totalThru;

  double useThru;

  double bestEverPivot;

  double increaseInObjective;

  double tentativeTheta;

  double lastPivotValue;

  double thisPivotValue;

  double thruThis;

  double increaseInThis;

  int lastSequence;

  int sequence;

  int block;

  int numberSwapped;

  int numberRemaining;

  int numberLastSwapped;

  bool modifyCosts;

} dualColumnResult;

class AbcSimplexDual : public AbcSimplex {


public:

  int dual();

  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);

  AbcSimplexFactorization *setupForStrongBranching(char *arrays, int numberRows,

    int numberColumns, bool solveLp = false);

  void cleanupAfterStrongBranching(AbcSimplexFactorization *factorization);


  int whileIteratingSerial();

#if ABC_PARALLEL == 1

  int whileIteratingThread();

#endif

#if ABC_PARALLEL == 2

  int whileIteratingCilk();

#endif

  void whileIterating2();

  int whileIteratingParallel(int numberIterations);

  int whileIterating3();

  void updatePrimalSolution();

  int noPivotRow();

  int noPivotColumn();

  void dualPivotColumn();

  void createDualPricingVectorSerial();

  int getTableauColumnFlipAndStartReplaceSerial();

  void getTableauColumnPart1Serial();

#if ABC_PARALLEL == 1

  void createDualPricingVectorThread();

  int getTableauColumnFlipAndStartReplaceThread();

  void getTableauColumnPart1Thread();

#endif

#if ABC_PARALLEL == 2

  void createDualPricingVectorCilk();

  int getTableauColumnFlipAndStartReplaceCilk();

  void getTableauColumnPart1Cilk();

#endif

  void getTableauColumnPart2();

  int checkReplace();

  void replaceColumnPart3();

  void checkReplacePart1();

  void checkReplacePart1a();

  void checkReplacePart1b();

  void updateDualsInDual();

  //void updateDualsInValuesPass(CoinIndexedVector * array,

  //                           double theta);

  int flipBounds();

  void flipBack(int number);

  void dualColumn1(bool doAll = false);

  double dualColumn1A();

  double dualColumn1B();

  void dualColumn2();

  void dualColumn2Most(dualColumnResult &result);

  void dualColumn2First(dualColumnResult &result);

  void dualColumn2(dualColumnResult &result);

  void checkPossibleCleanup(CoinIndexedVector *array);

  void dualPivotRow();

  int changeBounds(int initialize, double &changeCost);

  bool changeBound(int iSequence);

  void originalBound(int iSequence);

  int checkUnbounded(CoinIndexedVector &ray, double changeCost);

  void statusOfProblemInDual(int type);

  int whatNext();

  bool checkCutoff(bool computeObjective);

  int bounceTolerances(int type);

  void perturb(double factor);

  void perturbB(double factor, int type);

  int makeNonFreeVariablesDualFeasible(bool changeCosts = false);

  int fastDual(bool alwaysFinish = false);

  int numberAtFakeBound();


  int pivotResultPart1();

  int nextSuperBasic();

  void startupSolve();

  void finishSolve();

  void gutsOfDual();

  //int dual2(int ifValuesPass,int startFinishOptions=0);

  int resetFakeBounds(int type);


};

#if ABC_PARALLEL == 1

void *abc_parallelManager(void *simplex);

#endif

#endif


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

*/