ClpSimplexOther.hpp

Go to the documentation of this file.

/* $Id: ClpSimplexOther.hpp 2070 2014-11-18 11:12:54Z forrest $ */
// Copyright (C) 2004, 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 ClpSimplexOther_H
#define ClpSimplexOther_H
 
#include "ClpSimplex.hpp"
 
class ClpSimplexOther : public ClpSimplex {
 
public:
 
     void dualRanging(int numberCheck, const int * which,
                      double * costIncrease, int * sequenceIncrease,
                      double * costDecrease, int * sequenceDecrease,
                      double * valueIncrease = NULL, double * valueDecrease = NULL);
     void primalRanging(int numberCheck, const int * which,
                        double * valueIncrease, int * sequenceIncrease,
                        double * valueDecrease, int * sequenceDecrease);
     int parametrics(double startingTheta, double & endingTheta, double reportIncrement,
                     const double * changeLowerBound, const double * changeUpperBound,
                     const double * changeLowerRhs, const double * changeUpperRhs,
                     const double * changeObjective);
     int parametrics(const char * dataFile);
     int parametrics(double startingTheta, double & endingTheta, 
                     const double * changeLowerBound, const double * changeUpperBound,
                     const double * changeLowerRhs, const double * changeUpperRhs);
     int parametricsObj(double startingTheta, double & endingTheta, 
                        const double * changeObjective);
    double bestPivot(bool justColumns=false);
  typedef struct {
    double startingTheta;
    double endingTheta;
    double maxTheta;
    double acceptableMaxTheta; // if this far then within tolerances
    double * lowerChange; // full array of lower bound changes
    int * lowerList; // list of lower bound changes
    double * upperChange; // full array of upper bound changes
    int * upperList; // list of upper bound changes
    char * markDone; // mark which ones looked at
    int * backwardBasic; // from sequence to pivot row
    int * lowerActive;
    double * lowerGap;
    double * lowerCoefficient;
    int * upperActive;
    double * upperGap;
    double * upperCoefficient;
    int unscaledChangesOffset; 
    bool firstIteration; // so can update rhs for accuracy
  } parametricsData;
 
private:
     int parametricsLoop(parametricsData & paramData, double reportIncrement,
                         const double * changeLower, const double * changeUpper,
                         const double * changeObjective, ClpDataSave & data,
                         bool canTryQuick);
     int parametricsLoop(parametricsData & paramData,
                         ClpDataSave & data,bool canSkipFactorization=false);
     int parametricsObjLoop(parametricsData & paramData,
                         ClpDataSave & data,bool canSkipFactorization=false);
     void statusOfProblemInParametrics(int type, ClpDataSave & saveData);
     void statusOfProblemInParametricsObj(int type, ClpDataSave & saveData);
     int whileIterating(parametricsData & paramData, double reportIncrement,
                        const double * changeObjective);
     int nextTheta(int type, double maxTheta, parametricsData & paramData,
                   const double * changeObjective);
     int whileIteratingObj(parametricsData & paramData);
     int nextThetaObj(double maxTheta, parametricsData & paramData);
     void originalBound(int iSequence, double theta, const double * changeLower,
                     const double * changeUpper);
     double computeRhsEtc(parametricsData & paramData);
     void redoInternalArrays();
     void checkDualRatios(CoinIndexedVector * rowArray,
                          CoinIndexedVector * columnArray,
                          double & costIncrease, int & sequenceIncrease, double & alphaIncrease,
                          double & costDecrease, int & sequenceDecrease, double & alphaDecrease);
     void checkPrimalRatios(CoinIndexedVector * rowArray,
                            int direction);
     double primalRanging1(int whichIn, int whichOther);
 
public:
     int writeBasis(const char *filename,
                    bool writeValues = false,
                    int formatType = 0) const;
     int readBasis(const char *filename);
     ClpSimplex * dualOfModel(double fractionRowRanges = 1.0, double fractionColumnRanges = 1.0) const;
     int restoreFromDual(const ClpSimplex * dualProblem,
                         bool checkAccuracy=false);
     int setInDual(ClpSimplex * dualProblem);
     ClpSimplex * crunch(double * rhs, int * whichRows, int * whichColumns,
                         int & nBound, bool moreBounds = false, bool tightenBounds = false);
     void afterCrunch(const ClpSimplex & small,
                      const int * whichRows, const int * whichColumns,
                      int nBound);
     ClpSimplex * gubVersion(int * whichRows, int * whichColumns,
                             int neededGub,
                             int factorizationFrequency=50);
     void setGubBasis(ClpSimplex &original,const int * whichRows,
                      const int * whichColumns);
     void getGubBasis(ClpSimplex &original,const int * whichRows,
                      const int * whichColumns) const;
     void cleanupAfterPostsolve();
     int tightenIntegerBounds(double * rhsSpace);
     int expandKnapsack(int knapsackRow, int & numberOutput,
                        double * buildObj, CoinBigIndex * buildStart,
                        int * buildRow, double * buildElement, int reConstruct = -1) const;
};
#endif