ruby-cbc 0.1.9 → 0.2.1

data/ext/ruby-cbc/install/include/coin/ClpSimplexDual.hpp

@@ -1,300 +0,0 @@
-/* $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"
-
-/** This solves LPs using the dual simplex method
-
-    It inherits from ClpSimplex.  It has no data of its own and
-    is never created - only cast from a ClpSimplex object at algorithm time.
-
-*/
-
-class ClpSimplexDual : public ClpSimplex {
-
-public:
-
-     /**@name Description of algorithm */
-     //@{
-     /** Dual algorithm
-
-         Method
-
-        It tries to be a single phase approach with a weight of 1.0 being
-        given to getting optimal and a weight of updatedDualBound_ being
-        given to getting dual feasible.  In this version I have used the
-        idea that this weight can be thought of as a fake bound.  If the
-        distance between the lower and upper bounds on a variable is less
-        than the feasibility weight then we are always better off flipping
-        to other bound to make dual feasible.  If the distance is greater
-        then we make up a fake bound updatedDualBound_ away from one bound.
-        If we end up optimal or primal infeasible, we check to see if
-        bounds okay.  If so we have finished, if not we increase updatedDualBound_
-        and continue (after checking if unbounded). I am undecided about
-        free variables - there is coding but I am not sure about it.  At
-        present I put them in basis anyway.
-
-        The code is designed to take advantage of sparsity so arrays are
-        seldom zeroed out from scratch or gone over in their entirety.
-        The only exception is a full scan to find outgoing variable for
-        Dantzig row choice.  For steepest edge we keep an updated list
-        of infeasibilities (actually squares).
-        On easy problems we don't need full scan - just
-        pick first reasonable.
-
-        One problem is how to tackle degeneracy and accuracy.  At present
-        I am using the modification of costs which I put in OSL and some
-        of what I think is the dual analog of Gill et al.
-        I am still not sure of the exact details.
-
-        The flow of dual is three while loops as follows:
-
-        while (not finished) {
-
-          while (not clean solution) {
-
-             Factorize and/or clean up solution by flipping variables so
-         dual feasible.  If looks finished check fake dual bounds.
-         Repeat until status is iterating (-1) or finished (0,1,2)
-
-          }
-
-          while (status==-1) {
-
-            Iterate until no pivot in or out or time to re-factorize.
-
-            Flow is:
-
-            choose pivot row (outgoing variable).  if none then
-        we are primal feasible so looks as if done but we need to
-        break and check bounds etc.
-
-        Get pivot row in tableau
-
-            Choose incoming column.  If we don't find one then we look
-        primal infeasible so break and check bounds etc.  (Also the
-        pivot tolerance is larger after any iterations so that may be
-        reason)
-
-            If we do find incoming column, we may have to adjust costs to
-        keep going forwards (anti-degeneracy).  Check pivot will be stable
-        and if unstable throw away iteration and break to re-factorize.
-        If minor error re-factorize after iteration.
-
-        Update everything (this may involve flipping variables to stay
-        dual feasible.
-
-          }
-
-        }
-
-        TODO's (or maybe not)
-
-        At present we never check we are going forwards.  I overdid that in
-        OSL so will try and make a last resort.
-
-        Needs partial scan pivot out option.
-
-        May need other anti-degeneracy measures, especially if we try and use
-        loose tolerances as a way to solve in fewer iterations.
-
-        I like idea of dynamic scaling.  This gives opportunity to decouple
-        different implications of scaling for accuracy, iteration count and
-        feasibility tolerance.
-
-        for use of exotic parameter startFinishoptions see Clpsimplex.hpp
-     */
-
-     int dual(int ifValuesPass, int startFinishOptions = 0);
-     /** For strong branching.  On input lower and upper are new bounds
-         while on output they are change in objective function values
-         (>1.0e50 infeasible).
-         Return code is 0 if nothing interesting, -1 if infeasible both
-         ways and +1 if infeasible one way (check values to see which one(s))
-         Solutions are filled in as well - even down, odd up - also
-         status and number of iterations
-     */
-     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);
-     /// This does first part of StrongBranching
-     ClpFactorization * setupForStrongBranching(char * arrays, int numberRows,
-               int numberColumns, bool solveLp = false);
-     /// This cleans up after strong branching
-     void cleanupAfterStrongBranching(ClpFactorization * factorization);
-     //@}
-
-     /**@name Functions used in dual */
-     //@{
-     /** This has the flow between re-factorizations
-         Broken out for clarity and will be used by strong branching
-
-         Reasons to come out:
-         -1 iterations etc
-         -2 inaccuracy
-         -3 slight inaccuracy (and done iterations)
-         +0 looks optimal (might be unbounded - but we will investigate)
-         +1 looks infeasible
-         +3 max iterations
-
-         If givenPi not NULL then in values pass
-      */
-     int whileIterating(double * & givenPi, int ifValuesPass);
-     /** The duals are updated by the given arrays.
-         Returns number of infeasibilities.
-         After rowArray and columnArray will just have those which
-         have been flipped.
-         Variables may be flipped between bounds to stay dual feasible.
-         The output vector has movement of primal
-         solution (row length array) */
-     int updateDualsInDual(CoinIndexedVector * rowArray,
-                           CoinIndexedVector * columnArray,
-                           CoinIndexedVector * outputArray,
-                           double theta,
-                           double & objectiveChange,
-                           bool fullRecompute);
-     /** The duals are updated by the given arrays.
-         This is in values pass - so no changes to primal is made
-     */
-     void updateDualsInValuesPass(CoinIndexedVector * rowArray,
-                                  CoinIndexedVector * columnArray,
-                                  double theta);
-     /** While updateDualsInDual sees what effect is of flip
-         this does actual flipping.
-     */
-     void flipBounds(CoinIndexedVector * rowArray,
-                     CoinIndexedVector * columnArray);
-     /**
-         Row array has row part of pivot row
-         Column array has column part.
-         This chooses pivot column.
-         Spare arrays are used to save pivots which will go infeasible
-         We will check for basic so spare array will never overflow.
-         If necessary will modify costs
-         For speed, we may need to go to a bucket approach when many
-         variables are being flipped.
-         Returns best possible pivot value
-     */
-     double dualColumn(CoinIndexedVector * rowArray,
-                       CoinIndexedVector * columnArray,
-                       CoinIndexedVector * spareArray,
-                       CoinIndexedVector * spareArray2,
-                       double accpetablePivot,
-                       CoinBigIndex * dubiousWeights);
-     /// Does first bit of dualColumn
-     int dualColumn0(const CoinIndexedVector * rowArray,
-                     const CoinIndexedVector * columnArray,
-                     CoinIndexedVector * spareArray,
-                     double acceptablePivot,
-                     double & upperReturn, double &bestReturn, double & badFree);
-     /**
-         Row array has row part of pivot row
-         Column array has column part.
-         This sees what is best thing to do in dual values pass
-         if sequenceIn==sequenceOut can change dual on chosen row and leave variable in basis
-     */
-     void checkPossibleValuesMove(CoinIndexedVector * rowArray,
-                                  CoinIndexedVector * columnArray,
-                                  double acceptablePivot);
-     /**
-         Row array has row part of pivot row
-         Column array has column part.
-         This sees what is best thing to do in branch and bound cleanup
-         If sequenceIn_ < 0 then can't do anything
-     */
-     void checkPossibleCleanup(CoinIndexedVector * rowArray,
-                               CoinIndexedVector * columnArray,
-                               double acceptablePivot);
-     /**
-         This sees if we can move duals in dual values pass.
-         This is done before any pivoting
-     */
-     void doEasyOnesInValuesPass(double * givenReducedCosts);
-     /**
-         Chooses dual pivot row
-         Would be faster with separate region to scan
-         and will have this (with square of infeasibility) when steepest
-         For easy problems we can just choose one of the first rows we look at
-
-         If alreadyChosen >=0 then in values pass and that row has been
-         selected
-     */
-     void dualRow(int alreadyChosen);
-     /** Checks if any fake bounds active - if so returns number and modifies
-         updatedDualBound_ and everything.
-         Free variables will be left as free
-         Returns number of bounds changed if >=0
-         Returns -1 if not initialize and no effect
-         Fills in changeVector which can be used to see if unbounded
-         and cost of change vector
-         If 2 sets to original (just changed)
-     */
-     int changeBounds(int initialize, CoinIndexedVector * outputArray,
-                      double & changeCost);
-     /** As changeBounds but just changes new bounds for a single variable.
-         Returns true if change */
-     bool changeBound( int iSequence);
-     /// Restores bound to original bound
-     void originalBound(int iSequence);
-     /** Checks if tentative optimal actually means unbounded in dual
-         Returns -3 if not, 2 if is unbounded */
-     int checkUnbounded(CoinIndexedVector * ray, CoinIndexedVector * spare,
-                        double changeCost);
-     /**  Refactorizes if necessary
-          Checks if finished.  Updates status.
-          lastCleaned refers to iteration at which some objective/feasibility
-          cleaning too place.
-
-          type - 0 initial so set up save arrays etc
-               - 1 normal -if good update save
-           - 2 restoring from saved
-     */
-     void statusOfProblemInDual(int & lastCleaned, int type,
-                                double * givenDjs, ClpDataSave & saveData,
-                                int ifValuesPass);
-     /** Perturbs problem (method depends on perturbation())
-         returns nonzero if should go to dual */
-     int perturb();
-     /** Fast iterations.  Misses out a lot of initialization.
-         Normally stops on maximum iterations, first re-factorization
-         or tentative optimum.  If looks interesting then continues as
-         normal.  Returns 0 if finished properly, 1 otherwise.
-     */
-     int fastDual(bool alwaysFinish = false);
-     /** Checks number of variables at fake bounds.  This is used by fastDual
-         so can exit gracefully before end */
-     int numberAtFakeBound();
-
-     /** Pivot in a variable and choose an outgoing one.  Assumes dual
-         feasible - will not go through a reduced cost.  Returns step length in theta
-         Return codes as before but -1 means no acceptable pivot
-     */
-     int pivotResultPart1();
-     /** Get next free , -1 if none */
-     int nextSuperBasic();
-     /** Startup part of dual (may be extended to other algorithms)
-         returns 0 if good, 1 if bad */
-     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

data/ext/ruby-cbc/install/include/coin/ClpSimplexNonlinear.hpp

@@ -1,117 +0,0 @@
-/* $Id: ClpSimplexNonlinear.hpp 2025 2014-03-19 12:49:55Z 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 ClpSimplexNonlinear_H
-#define ClpSimplexNonlinear_H
-
-class ClpNonlinearInfo;
-class ClpQuadraticObjective;
-class ClpConstraint;
-
-#include "ClpSimplexPrimal.hpp"
-
-/** This solves non-linear LPs using the primal simplex method
-
-    It inherits from ClpSimplexPrimal.  It has no data of its own and
-    is never created - only cast from a ClpSimplexPrimal object at algorithm time.
-    If needed create new class and pass around
-
-*/
-
-class ClpSimplexNonlinear : public ClpSimplexPrimal {
-
-public:
-
-     /**@name Description of algorithm */
-     //@{
-     /** Primal algorithms for reduced gradient
-         At present we have two algorithms:
-
-     */
-     /// A reduced gradient method.
-     int primal();
-     /** Primal algorithm for quadratic
-         Using a semi-trust region approach as for pooling problem
-         This is in because I have it lying around
-     */
-     int primalSLP(int numberPasses, double deltaTolerance,
-		int otherOptions=0);
-     /// May use a cut approach for solving any LP
-     int primalDualCuts(char * rowsIn, int startUp, int algorithm);
-     /** Primal algorithm for nonlinear constraints
-         Using a semi-trust region approach as for pooling problem
-         This is in because I have it lying around
-
-     */
-     int primalSLP(int numberConstraints, ClpConstraint ** constraints,
-                   int numberPasses, double deltaTolerance);
-
-     /** Creates direction vector.  note longArray is long enough
-         for rows and columns.  If numberNonBasic 0 then is updated
-         otherwise mode is ignored and those are used.
-         Norms are only for those > 1.0e3*dualTolerance
-         If mode is nonzero then just largest dj */
-     void directionVector (CoinIndexedVector * longArray,
-                           CoinIndexedVector * spare1, CoinIndexedVector * spare2,
-                           int mode,
-                           double & normFlagged, double & normUnflagged,
-                           int & numberNonBasic);
-     /// Main part.
-     int whileIterating (int & pivotMode);
-     /**
-         longArray has direction
-         pivotMode -
-               0 - use all dual infeasible variables
-           1 - largest dj
-           while >= 10 trying startup phase
-         Returns 0 - can do normal iteration (basis change)
-         1 - no basis change
-         2 - if wants singleton
-         3 - if time to re-factorize
-         If sequenceIn_ >=0 then that will be incoming variable
-     */
-     int pivotColumn(CoinIndexedVector * longArray,
-                     CoinIndexedVector * rowArray,
-                     CoinIndexedVector * columnArray,
-                     CoinIndexedVector * spare,
-                     int & pivotMode,
-                     double & solutionError,
-                     double * array1);
-     /**  Refactorizes if necessary
-          Checks if finished.  Updates status.
-          lastCleaned refers to iteration at which some objective/feasibility
-          cleaning too place.
-
-          type - 0 initial so set up save arrays etc
-               - 1 normal -if good update save
-           - 2 restoring from saved
-     */
-     void statusOfProblemInPrimal(int & lastCleaned, int type,
-                                  ClpSimplexProgress * progress,
-                                  bool doFactorization,
-                                  double & bestObjectiveWhenFlagged);
-     /** Do last half of an iteration.
-         Return codes
-         Reasons to come out normal mode
-         -1 normal
-         -2 factorize now - good iteration
-         -3 slight inaccuracy - refactorize - iteration done
-         -4 inaccuracy - refactorize - no iteration
-         -5 something flagged - go round again
-         +2 looks unbounded
-         +3 max iterations (iteration done)
-
-     */
-     int pivotNonlinearResult();
-     //@}
-
-};
-#endif
-

data/ext/ruby-cbc/install/include/coin/ClpSimplexOther.hpp

@@ -1,277 +0,0 @@
-/* $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"
-
-/** This is for Simplex stuff which is neither dual nor primal
-
-    It inherits from ClpSimplex.  It has no data of its own and
-    is never created - only cast from a ClpSimplex object at algorithm time.
-
-*/
-
-class ClpSimplexOther : public ClpSimplex {
-
-public:
-
-     /**@name Methods */
-     //@{
-     /** Dual ranging.
-         This computes increase/decrease in cost for each given variable and corresponding
-         sequence numbers which would change basis.  Sequence numbers are 0..numberColumns
-         and numberColumns.. for artificials/slacks.
-         For non-basic variables the information is trivial to compute and the change in cost is just minus the
-         reduced cost and the sequence number will be that of the non-basic variables.
-         For basic variables a ratio test is between the reduced costs for non-basic variables
-         and the row of the tableau corresponding to the basic variable.
-         The increase/decrease value is always >= 0.0
-
-         Up to user to provide correct length arrays where each array is of length numberCheck.
-         which contains list of variables for which information is desired.  All other
-         arrays will be filled in by function.  If fifth entry in which is variable 7 then fifth entry in output arrays
-         will be information for variable 7.
-
-         If valueIncrease/Decrease not NULL (both must be NULL or both non NULL) then these are filled with
-         the value of variable if such a change in cost were made (the existing bounds are ignored)
-
-         When here - guaranteed optimal
-     */
-     void dualRanging(int numberCheck, const int * which,
-                      double * costIncrease, int * sequenceIncrease,
-                      double * costDecrease, int * sequenceDecrease,
-                      double * valueIncrease = NULL, double * valueDecrease = NULL);
-     /** Primal ranging.
-         This computes increase/decrease in value for each given variable and corresponding
-         sequence numbers which would change basis.  Sequence numbers are 0..numberColumns
-         and numberColumns.. for artificials/slacks.
-         This should only be used for non-basic variabls as otherwise information is pretty useless
-         For basic variables the sequence number will be that of the basic variables.
-
-         Up to user to provide correct length arrays where each array is of length numberCheck.
-         which contains list of variables for which information is desired.  All other
-         arrays will be filled in by function.  If fifth entry in which is variable 7 then fifth entry in output arrays
-         will be information for variable 7.
-
-         When here - guaranteed optimal
-     */
-     void primalRanging(int numberCheck, const int * which,
-                        double * valueIncrease, int * sequenceIncrease,
-                        double * valueDecrease, int * sequenceDecrease);
-     /** Parametrics
-         This is an initial slow version.
-         The code uses current bounds + theta * change (if change array not NULL)
-         and similarly for objective.
-         It starts at startingTheta and returns ending theta in endingTheta.
-         If reportIncrement 0.0 it will report on any movement
-         If reportIncrement >0.0 it will report at startingTheta+k*reportIncrement.
-         If it can not reach input endingTheta return code will be 1 for infeasible,
-         2 for unbounded, if error on ranges -1,  otherwise 0.
-         Normal report is just theta and objective but
-         if event handler exists it may do more
-         On exit endingTheta is maximum reached (can be used for next startingTheta)
-     */
-     int parametrics(double startingTheta, double & endingTheta, double reportIncrement,
-                     const double * changeLowerBound, const double * changeUpperBound,
-                     const double * changeLowerRhs, const double * changeUpperRhs,
-                     const double * changeObjective);
-     /** Version of parametrics which reads from file
-	 See CbcClpParam.cpp for details of format
-	 Returns -2 if unable to open file */
-     int parametrics(const char * dataFile);
-     /** Parametrics
-         This is an initial slow version.
-         The code uses current bounds + theta * change (if change array not NULL)
-         It starts at startingTheta and returns ending theta in endingTheta.
-         If it can not reach input endingTheta return code will be 1 for infeasible,
-         2 for unbounded, if error on ranges -1,  otherwise 0.
-         Event handler may do more
-         On exit endingTheta is maximum reached (can be used for next startingTheta)
-     */
-     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);
-    /// Finds best possible pivot
-    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:
-     /** Parametrics - inner loop
-         This first attempt is when reportIncrement non zero and may
-         not report endingTheta correctly
-         If it can not reach input endingTheta return code will be 1 for infeasible,
-         2 for unbounded,  otherwise 0.
-         Normal report is just theta and objective but
-         if event handler exists it may do more
-     */
-     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);
-     /**  Refactorizes if necessary
-          Checks if finished.  Updates status.
-
-          type - 0 initial so set up save arrays etc
-               - 1 normal -if good update save
-           - 2 restoring from saved
-     */
-     void statusOfProblemInParametrics(int type, ClpDataSave & saveData);
-     void statusOfProblemInParametricsObj(int type, ClpDataSave & saveData);
-     /** This has the flow between re-factorizations
-
-         Reasons to come out:
-         -1 iterations etc
-         -2 inaccuracy
-         -3 slight inaccuracy (and done iterations)
-         +0 looks optimal (might be unbounded - but we will investigate)
-         +1 looks infeasible
-         +3 max iterations
-      */
-     int whileIterating(parametricsData & paramData, double reportIncrement,
-                        const double * changeObjective);
-     /** Computes next theta and says if objective or bounds (0= bounds, 1 objective, -1 none).
-         theta is in theta_.
-         type 1 bounds, 2 objective, 3 both.
-     */
-     int nextTheta(int type, double maxTheta, parametricsData & paramData,
-                   const double * changeObjective);
-     int whileIteratingObj(parametricsData & paramData);
-     int nextThetaObj(double maxTheta, parametricsData & paramData);
-     /// Restores bound to original bound
-     void originalBound(int iSequence, double theta, const double * changeLower,
-		     const double * changeUpper);
-     /// Compute new rowLower_ etc (return negative if infeasible - otherwise largest change)
-     double computeRhsEtc(parametricsData & paramData);
-     /// Redo lower_ from rowLower_ etc
-     void redoInternalArrays();
-     /**
-         Row array has row part of pivot row
-         Column array has column part.
-         This is used in dual ranging
-     */
-     void checkDualRatios(CoinIndexedVector * rowArray,
-                          CoinIndexedVector * columnArray,
-                          double & costIncrease, int & sequenceIncrease, double & alphaIncrease,
-                          double & costDecrease, int & sequenceDecrease, double & alphaDecrease);
-     /**
-         Row array has pivot column
-         This is used in primal ranging
-     */
-     void checkPrimalRatios(CoinIndexedVector * rowArray,
-                            int direction);
-     /// Returns new value of whichOther when whichIn enters basis
-     double primalRanging1(int whichIn, int whichOther);
-
-public:
-     /** Write the basis in MPS format to the specified file.
-     If writeValues true writes values of structurals
-     (and adds VALUES to end of NAME card)
-
-     Row and column names may be null.
-     formatType is
-     <ul>
-       <li> 0 - normal
-       <li> 1 - extra accuracy
-       <li> 2 - IEEE hex (later)
-     </ul>
-
-     Returns non-zero on I/O error
-     */
-     int writeBasis(const char *filename,
-                    bool writeValues = false,
-                    int formatType = 0) const;
-     /// Read a basis from the given filename
-     int readBasis(const char *filename);
-     /** Creates dual of a problem if looks plausible
-         (defaults will always create model)
-         fractionRowRanges is fraction of rows allowed to have ranges
-         fractionColumnRanges is fraction of columns allowed to have ranges
-     */
-     ClpSimplex * dualOfModel(double fractionRowRanges = 1.0, double fractionColumnRanges = 1.0) const;
-     /** Restores solution from dualized problem
-         non-zero return code indicates minor problems
-     */
-     int restoreFromDual(const ClpSimplex * dualProblem,
-			 bool checkAccuracy=false);
-     /** Sets solution in dualized problem
-         non-zero return code indicates minor problems
-     */
-     int setInDual(ClpSimplex * dualProblem);
-     /** Does very cursory presolve.
-         rhs is numberRows, whichRows is 3*numberRows and whichColumns is 2*numberColumns.
-     */
-     ClpSimplex * crunch(double * rhs, int * whichRows, int * whichColumns,
-                         int & nBound, bool moreBounds = false, bool tightenBounds = false);
-     /** After very cursory presolve.
-         rhs is numberRows, whichRows is 3*numberRows and whichColumns is 2*numberColumns.
-     */
-     void afterCrunch(const ClpSimplex & small,
-                      const int * whichRows, const int * whichColumns,
-                      int nBound);
-     /** Returns gub version of model or NULL
-	 whichRows has to be numberRows
-	 whichColumns has to be numberRows+numberColumns */
-     ClpSimplex * gubVersion(int * whichRows, int * whichColumns,
-			     int neededGub,
-			     int factorizationFrequency=50);
-     /// Sets basis from original
-     void setGubBasis(ClpSimplex &original,const int * whichRows,
-		      const int * whichColumns);
-     /// Restores basis to original
-     void getGubBasis(ClpSimplex &original,const int * whichRows,
-		      const int * whichColumns) const;
-     /// Quick try at cleaning up duals if postsolve gets wrong
-     void cleanupAfterPostsolve();
-     /** Tightens integer bounds - returns number tightened or -1 if infeasible
-     */
-     int tightenIntegerBounds(double * rhsSpace);
-     /** Expands out all possible combinations for a knapsack
-         If buildObj NULL then just computes space needed - returns number elements
-         On entry numberOutput is maximum allowed, on exit it is number needed or
-         -1 (as will be number elements) if maximum exceeded.  numberOutput will have at
-         least space to return values which reconstruct input.
-         Rows returned will be original rows but no entries will be returned for
-         any rows all of whose entries are in knapsack.  So up to user to allow for this.
-         If reConstruct >=0 then returns number of entrie which make up item "reConstruct"
-         in expanded knapsack.  Values in buildRow and buildElement;
-     */
-     int expandKnapsack(int knapsackRow, int & numberOutput,
-                        double * buildObj, CoinBigIndex * buildStart,
-                        int * buildRow, double * buildElement, int reConstruct = -1) const;
-     //@}
-};
-#endif