AbcSimplexDual.hpp

Go to the documentation of this file.

/* $Id: AbcSimplexDual.hpp 1910 2013-01-27 02:00:13Z stefan $ */
// 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