cbcintlinprog added

1 files changed, 0 insertions, 1797 deletions

diff --git a/newstructure/thirdparty/linux/include/coin/ClpSimplex.hpp b/newstructure/thirdparty/linux/include/coin/ClpSimplex.hpp
deleted file mode 100644
index bab4506..0000000
--- a/newstructure/thirdparty/linux/include/coin/ClpSimplex.hpp
+++ /dev/null
@@ -1,1797 +0,0 @@
-/* $Id: ClpSimplex.hpp 2114 2015-02-10 12:12:46Z 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 ClpSimplex_H
-#define ClpSimplex_H
-
-#include <iostream>
-#include <cfloat>
-#include "ClpModel.hpp"
-#include "ClpMatrixBase.hpp"
-#include "ClpSolve.hpp"
-#include "ClpConfig.h"
-class ClpDualRowPivot;
-class ClpPrimalColumnPivot;
-class ClpFactorization;
-class CoinIndexedVector;
-class ClpNonLinearCost;
-class ClpNodeStuff;
-class CoinStructuredModel;
-class OsiClpSolverInterface;
-class CoinWarmStartBasis;
-class ClpDisasterHandler;
-class ClpConstraint;
-/*
-  May want to use Clp defaults so that with ABC defined but not used
-  it behaves as Clp (and ABC used will be different than if not defined)
- */
-#ifdef ABC_INHERIT
-#ifndef CLP_INHERIT_MODE
-#define CLP_INHERIT_MODE 1
-#endif
-#ifndef ABC_CLP_DEFAULTS
-#define ABC_CLP_DEFAULTS 0
-#endif
-#else
-#undef ABC_CLP_DEFAULTS
-#define ABC_CLP_DEFAULTS 1
-#endif
-#ifdef CLP_HAS_ABC
-#include "AbcCommon.hpp"
-class AbcTolerancesEtc;
-class AbcSimplex;
-#include "CoinAbcCommon.hpp"
-#endif
-/** This solves LPs using the simplex method
-
-    It inherits from ClpModel and all its arrays are created at
-    algorithm time. Originally I tried to work with model arrays
-    but for simplicity of coding I changed to single arrays with
-    structural variables then row variables.  Some coding is still
-    based on old style and needs cleaning up.
-
-    For a description of algorithms:
-
-    for dual see ClpSimplexDual.hpp and at top of ClpSimplexDual.cpp
-    for primal see ClpSimplexPrimal.hpp and at top of ClpSimplexPrimal.cpp
-
-    There is an algorithm data member.  + for primal variations
-    and - for dual variations
-
-*/
-
-class ClpSimplex : public ClpModel {
-     friend void ClpSimplexUnitTest(const std::string & mpsDir);
-
-public:
-     /** enums for status of various sorts.
-         First 4 match CoinWarmStartBasis,
-         isFixed means fixed at lower bound and out of basis
-     */
-     enum Status {
-          isFree = 0x00,
-          basic = 0x01,
-          atUpperBound = 0x02,
-          atLowerBound = 0x03,
-          superBasic = 0x04,
-          isFixed = 0x05
-     };
-     // For Dual
-     enum FakeBound {
-          noFake = 0x00,
-          lowerFake = 0x01,
-          upperFake = 0x02,
-          bothFake = 0x03
-     };
-
-     /**@name Constructors and destructor and copy */
-     //@{
-     /// Default constructor
-     ClpSimplex (bool emptyMessages = false  );
-
-     /** Copy constructor. May scale depending on mode
-         -1 leave mode as is
-         0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later)
-     */
-     ClpSimplex(const ClpSimplex & rhs, int scalingMode = -1);
-     /** Copy constructor from model. May scale depending on mode
-         -1 leave mode as is
-         0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later)
-     */
-     ClpSimplex(const ClpModel & rhs, int scalingMode = -1);
-     /** Subproblem constructor.  A subset of whole model is created from the
-         row and column lists given.  The new order is given by list order and
-         duplicates are allowed.  Name and integer information can be dropped
-         Can optionally modify rhs to take into account variables NOT in list
-         in this case duplicates are not allowed (also see getbackSolution)
-     */
-     ClpSimplex (const ClpModel * wholeModel,
-                 int numberRows, const int * whichRows,
-                 int numberColumns, const int * whichColumns,
-                 bool dropNames = true, bool dropIntegers = true,
-                 bool fixOthers = false);
-     /** Subproblem constructor.  A subset of whole model is created from the
-         row and column lists given.  The new order is given by list order and
-         duplicates are allowed.  Name and integer information can be dropped
-         Can optionally modify rhs to take into account variables NOT in list
-         in this case duplicates are not allowed (also see getbackSolution)
-     */
-     ClpSimplex (const ClpSimplex * wholeModel,
-                 int numberRows, const int * whichRows,
-                 int numberColumns, const int * whichColumns,
-                 bool dropNames = true, bool dropIntegers = true,
-                 bool fixOthers = false);
-     /** This constructor modifies original ClpSimplex and stores
-         original stuff in created ClpSimplex.  It is only to be used in
-         conjunction with originalModel */
-     ClpSimplex (ClpSimplex * wholeModel,
-                 int numberColumns, const int * whichColumns);
-     /** This copies back stuff from miniModel and then deletes miniModel.
-         Only to be used with mini constructor */
-     void originalModel(ClpSimplex * miniModel);
-  inline int abcState() const
-  { return abcState_;}
-  inline void setAbcState(int state)
-  { abcState_=state;}
-#ifdef ABC_INHERIT
-  inline AbcSimplex * abcSimplex() const
-  { return abcSimplex_;}
-  inline void setAbcSimplex(AbcSimplex * simplex)
-  { abcSimplex_=simplex;}
-  /// Returns 0 if dual can be skipped
-  int doAbcDual();
-  /// Returns 0 if primal can be skipped
-  int doAbcPrimal(int ifValuesPass);
-#endif
-     /** Array persistence flag
-         If 0 then as now (delete/new)
-         1 then only do arrays if bigger needed
-         2 as 1 but give a bit extra if bigger needed
-     */
-     void setPersistenceFlag(int value);
-     /// Save a copy of model with certain state - normally without cuts
-     void makeBaseModel();
-     /// Switch off base model
-     void deleteBaseModel();
-     /// See if we have base model
-     inline ClpSimplex *  baseModel() const {
-          return baseModel_;
-     }
-     /** Reset to base model (just size and arrays needed)
-         If model NULL use internal copy
-     */
-     void setToBaseModel(ClpSimplex * model = NULL);
-     /// Assignment operator. This copies the data
-     ClpSimplex & operator=(const ClpSimplex & rhs);
-     /// Destructor
-     ~ClpSimplex (  );
-     // Ones below are just ClpModel with some changes
-     /** Loads a problem (the constraints on the
-           rows are given by lower and upper bounds). If a pointer is 0 then the
-           following values are the default:
-           <ul>
-             <li> <code>colub</code>: all columns have upper bound infinity
-             <li> <code>collb</code>: all columns have lower bound 0
-             <li> <code>rowub</code>: all rows have upper bound infinity
-             <li> <code>rowlb</code>: all rows have lower bound -infinity
-         <li> <code>obj</code>: all variables have 0 objective coefficient
-           </ul>
-       */
-     void loadProblem (  const ClpMatrixBase& matrix,
-                         const double* collb, const double* colub,
-                         const double* obj,
-                         const double* rowlb, const double* rowub,
-                         const double * rowObjective = NULL);
-     void loadProblem (  const CoinPackedMatrix& matrix,
-                         const double* collb, const double* colub,
-                         const double* obj,
-                         const double* rowlb, const double* rowub,
-                         const double * rowObjective = NULL);
-
-     /** Just like the other loadProblem() method except that the matrix is
-       given in a standard column major ordered format (without gaps). */
-     void loadProblem (  const int numcols, const int numrows,
-                         const CoinBigIndex* start, const int* index,
-                         const double* value,
-                         const double* collb, const double* colub,
-                         const double* obj,
-                         const double* rowlb, const double* rowub,
-                         const double * rowObjective = NULL);
-     /// This one is for after presolve to save memory
-     void loadProblem (  const int numcols, const int numrows,
-                         const CoinBigIndex* start, const int* index,
-                         const double* value, const int * length,
-                         const double* collb, const double* colub,
-                         const double* obj,
-                         const double* rowlb, const double* rowub,
-                         const double * rowObjective = NULL);
-     /** This loads a model from a coinModel object - returns number of errors.
-         If keepSolution true and size is same as current then
-         keeps current status and solution
-     */
-     int loadProblem (  CoinModel & modelObject, bool keepSolution = false);
-     /// Read an mps file from the given filename
-     int readMps(const char *filename,
-                 bool keepNames = false,
-                 bool ignoreErrors = false);
-     /// Read GMPL files from the given filenames
-     int readGMPL(const char *filename, const char * dataName,
-                  bool keepNames = false);
-     /// Read file in LP format from file with name filename.
-     /// See class CoinLpIO for description of this format.
-     int readLp(const char *filename, const double epsilon = 1e-5);
-     /** Borrow model.  This is so we dont have to copy large amounts
-         of data around.  It assumes a derived class wants to overwrite
-         an empty model with a real one - while it does an algorithm.
-         This is same as ClpModel one, but sets scaling on etc. */
-     void borrowModel(ClpModel & otherModel);
-     void borrowModel(ClpSimplex & otherModel);
-     /// Pass in Event handler (cloned and deleted at end)
-     void passInEventHandler(const ClpEventHandler * eventHandler);
-     /// Puts solution back into small model
-     void getbackSolution(const ClpSimplex & smallModel, const int * whichRow, const int * whichColumn);
-     /** Load nonlinear part of problem from AMPL info
-         Returns 0 if linear
-         1 if quadratic objective
-         2 if quadratic constraints
-         3 if nonlinear objective
-         4 if nonlinear constraints
-         -1 on failure
-     */
-     int loadNonLinear(void * info, int & numberConstraints,
-                       ClpConstraint ** & constraints);
-#ifdef ABC_INHERIT
-  /// Loads tolerances etc
-  void loadTolerancesEtc(const AbcTolerancesEtc & data);
-  /// Unloads tolerances etc
-  void unloadTolerancesEtc(AbcTolerancesEtc & data);
-#endif
-     //@}
-
-     /**@name Functions most useful to user */
-     //@{
-     /** General solve algorithm which can do presolve.
-         See  ClpSolve.hpp for options
-      */
-     int initialSolve(ClpSolve & options);
-     /// Default initial solve
-     int initialSolve();
-     /// Dual initial solve
-     int initialDualSolve();
-     /// Primal initial solve
-     int initialPrimalSolve();
-     /// Barrier initial solve
-     int initialBarrierSolve();
-     /// Barrier initial solve, not to be followed by crossover
-     int initialBarrierNoCrossSolve();
-     /** Dual algorithm - see ClpSimplexDual.hpp for method.
-         ifValuesPass==2 just does values pass and then stops.
-
-         startFinishOptions - bits
-         1 - do not delete work areas and factorization at end
-         2 - use old factorization if same number of rows
-         4 - skip as much initialization of work areas as possible
-             (based on whatsChanged in clpmodel.hpp) ** work in progress
-         maybe other bits later
-     */
-     int dual(int ifValuesPass = 0, int startFinishOptions = 0);
-     // If using Debug
-     int dualDebug(int ifValuesPass = 0, int startFinishOptions = 0);
-     /** Primal algorithm - see ClpSimplexPrimal.hpp for method.
-         ifValuesPass==2 just does values pass and then stops.
-
-         startFinishOptions - bits
-         1 - do not delete work areas and factorization at end
-         2 - use old factorization if same number of rows
-         4 - skip as much initialization of work areas as possible
-             (based on whatsChanged in clpmodel.hpp) ** work in progress
-         maybe other bits later
-     */
-     int primal(int ifValuesPass = 0, int startFinishOptions = 0);
-     /** Solves nonlinear problem using SLP - may be used as crash
-         for other algorithms when number of iterations small.
-         Also exits if all problematical variables are changing
-         less than deltaTolerance
-     */
-     int nonlinearSLP(int numberPasses, double deltaTolerance);
-     /** Solves problem with nonlinear constraints using SLP - may be used as crash
-         for other algorithms when number of iterations small.
-         Also exits if all problematical variables are changing
-         less than deltaTolerance
-     */
-     int nonlinearSLP(int numberConstraints, ClpConstraint ** constraints,
-                      int numberPasses, double deltaTolerance);
-     /** Solves using barrier (assumes you have good cholesky factor code).
-         Does crossover to simplex if asked*/
-     int barrier(bool crossover = true);
-     /** Solves non-linear using reduced gradient.  Phase = 0 get feasible,
-         =1 use solution */
-     int reducedGradient(int phase = 0);
-     /// Solve using structure of model and maybe in parallel
-     int solve(CoinStructuredModel * model);
-#ifdef ABC_INHERIT
-  /** solvetype 0 for dual, 1 for primal
-      startup 1 for values pass
-      interrupt whether to pass across interrupt handler
-      add 10 to return AbcSimplex 
-  */
-  AbcSimplex * dealWithAbc(int solveType,int startUp,bool interrupt=false);
-  //void dealWithAbc(int solveType,int startUp,bool interrupt=false);
-#endif
-     /** This loads a model from a CoinStructuredModel object - returns number of errors.
-         If originalOrder then keep to order stored in blocks,
-         otherwise first column/rows correspond to first block - etc.
-         If keepSolution true and size is same as current then
-         keeps current status and solution
-     */
-     int loadProblem (  CoinStructuredModel & modelObject,
-                        bool originalOrder = true, bool keepSolution = false);
-     /**
-        When scaling is on it is possible that the scaled problem
-        is feasible but the unscaled is not.  Clp returns a secondary
-        status code to that effect.  This option allows for a cleanup.
-        If you use it I would suggest 1.
-        This only affects actions when scaled optimal
-        0 - no action
-        1 - clean up using dual if primal infeasibility
-        2 - clean up using dual if dual infeasibility
-        3 - clean up using dual if primal or dual infeasibility
-        11,12,13 - as 1,2,3 but use primal
-
-        return code as dual/primal
-     */
-     int cleanup(int cleanupScaling);
-     /** 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)
-
-         Returns non-zero if infeasible unbounded etc
-     */
-     int 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.
-
-         Returns non-zero if infeasible unbounded etc
-     */
-     int primalRanging(int numberCheck, const int * which,
-                       double * valueIncrease, int * sequenceIncrease,
-                       double * valueDecrease, int * sequenceDecrease);
-     /**
-	Modifies coefficients etc and if necessary pivots in and out.
-	All at same status will be done (basis may go singular).
-	User can tell which others have been done (i.e. if status matches).
-	If called from outside will change status and return 0.
-	If called from event handler returns non-zero if user has to take action.
-	indices>=numberColumns are slacks (obviously no coefficients)
-	status array is (char) Status enum
-     */
-     int modifyCoefficientsAndPivot(int number,
-				 const int * which,
-				 const CoinBigIndex * start,
-				 const int * row,
-				 const double * newCoefficient,
-				 const unsigned char * newStatus=NULL,
-				 const double * newLower=NULL,
-				 const double * newUpper=NULL,
-				 const double * newObjective=NULL);
-     /** Take out duplicate rows (includes scaled rows and intersections).
-	 On exit whichRows has rows to delete - return code is number can be deleted 
-	 or -1 if would be infeasible.
-	 If tolerance is -1.0 use primalTolerance for equality rows and infeasibility
-	 If cleanUp not zero then spend more time trying to leave more stable row
-	 and make row bounds exact multiple of cleanUp if close enough
-     */
-     int outDuplicateRows(int numberLook,int * whichRows, bool noOverlaps=false, double tolerance=-1.0,
-			  double cleanUp=0.0);
-     /** Try simple crash like techniques to get closer to primal feasibility
-	 returns final sum of infeasibilities */
-     double moveTowardsPrimalFeasible();
-     /** Try simple crash like techniques to remove super basic slacks
-	 but only if > threshold */
-     void removeSuperBasicSlacks(int threshold=0);
-     /** Mini presolve (faster)
-	 Char arrays must be numberRows and numberColumns long
-	 on entry second part must be filled in as follows -
-	 0 - possible
-	 >0 - take out and do something (depending on value - TBD)
-	 -1 row/column can't vanish but can have entries removed/changed
-	 -2 don't touch at all
-	 on exit <=0 ones will be in presolved problem
-	 struct will be created and will be long enough
-	 (information on length etc in first entry)
-	 user must delete struct
-     */
-     ClpSimplex * miniPresolve(char * rowType, char * columnType,void ** info);
-     /// After mini presolve
-     void miniPostsolve(const ClpSimplex * presolvedModel,void * info);
-     /// mini presolve and solve
-     void miniSolve(char * rowType, char *columnType,int algorithm, int startUp);
-     /** 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,
-         returns -1 on file error, 0 if no values, 1 if values */
-     int readBasis(const char *filename);
-     /// Returns a basis (to be deleted by user)
-     CoinWarmStartBasis * getBasis() const;
-     /// Passes in factorization
-     void setFactorization( ClpFactorization & factorization);
-     // Swaps factorization
-     ClpFactorization * swapFactorization( ClpFactorization * factorization);
-     /// Copies in factorization to existing one
-     void copyFactorization( ClpFactorization & factorization);
-     /** Tightens primal bounds to make dual faster.  Unless
-         fixed or doTight>10, bounds are slightly looser than they could be.
-         This is to make dual go faster and is probably not needed
-         with a presolve.  Returns non-zero if problem infeasible.
-
-         Fudge for branch and bound - put bounds on columns of factor *
-         largest value (at continuous) - should improve stability
-         in branch and bound on infeasible branches (0.0 is off)
-     */
-     int tightenPrimalBounds(double factor = 0.0, int doTight = 0, bool tightIntegers = false);
-     /** Crash - at present just aimed at dual, returns
-         -2 if dual preferred and crash basis created
-         -1 if dual preferred and all slack basis preferred
-          0 if basis going in was not all slack
-          1 if primal preferred and all slack basis preferred
-          2 if primal preferred and crash basis created.
-
-          if gap between bounds <="gap" variables can be flipped
-          ( If pivot -1 then can be made super basic!)
-
-          If "pivot" is
-          -1 No pivoting - always primal
-          0 No pivoting (so will just be choice of algorithm)
-          1 Simple pivoting e.g. gub
-          2 Mini iterations
-     */
-     int crash(double gap, int pivot);
-     /// Sets row pivot choice algorithm in dual
-     void setDualRowPivotAlgorithm(ClpDualRowPivot & choice);
-     /// Sets column pivot choice algorithm in primal
-     void setPrimalColumnPivotAlgorithm(ClpPrimalColumnPivot & choice);
-     /// Create a hotstart point of the optimization process
-     void markHotStart(void * & saveStuff);
-     /// Optimize starting from the hotstart
-     void solveFromHotStart(void * saveStuff);
-     /// Delete the snapshot
-     void unmarkHotStart(void * saveStuff);
-     /** 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);
-     /// Fathom - 1 if solution
-     int fathom(void * stuff);
-     /** Do up to N deep - returns
-         -1 - no solution nNodes_ valid nodes
-         >= if solution and that node gives solution
-         ClpNode array is 2**N long.  Values for N and
-         array are in stuff (nNodes_ also in stuff) */
-     int fathomMany(void * stuff);
-     /// Double checks OK
-     double doubleCheck();
-     /// Starts Fast dual2
-     int startFastDual2(ClpNodeStuff * stuff);
-     /// Like Fast dual
-     int fastDual2(ClpNodeStuff * stuff);
-     /// Stops Fast dual2
-     void stopFastDual2(ClpNodeStuff * stuff);
-     /** Deals with crunch aspects
-         mode 0 - in
-              1 - out with solution
-          2 - out without solution
-         returns small model or NULL
-     */
-     ClpSimplex * fastCrunch(ClpNodeStuff * stuff, int mode);
-     //@}
-
-     /**@name Needed for functionality of OsiSimplexInterface */
-     //@{
-     /** Pivot in a variable and out a variable.  Returns 0 if okay,
-         1 if inaccuracy forced re-factorization, -1 if would be singular.
-         Also updates primal/dual infeasibilities.
-         Assumes sequenceIn_ and pivotRow_ set and also directionIn and Out.
-     */
-     int pivot();
-
-     /** Pivot in a variable and choose an outgoing one.  Assumes primal
-         feasible - will not go through a bound.  Returns step length in theta
-         Returns ray in ray_ (or NULL if no pivot)
-         Return codes as before but -1 means no acceptable pivot
-     */
-     int primalPivotResult();
-
-     /** Pivot out a variable and choose an incoing 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 dualPivotResultPart1();
-     /** Do actual pivot
-	 state is 0 if need tableau column, 1 if in rowArray_[1]
-     */
-  int pivotResultPart2(int algorithm,int state);
-
-     /** Common bits of coding for dual and primal.  Return 0 if okay,
-         1 if bad matrix, 2 if very bad factorization
-
-         startFinishOptions - bits
-         1 - do not delete work areas and factorization at end
-         2 - use old factorization if same number of rows
-         4 - skip as much initialization of work areas as possible
-             (based on whatsChanged in clpmodel.hpp) ** work in progress
-         maybe other bits later
-
-     */
-     int startup(int ifValuesPass, int startFinishOptions = 0);
-     void finish(int startFinishOptions = 0);
-
-     /** Factorizes and returns true if optimal.  Used by user */
-     bool statusOfProblem(bool initial = false);
-     /// If user left factorization frequency then compute
-     void defaultFactorizationFrequency();
-     /// Copy across enabled stuff from one solver to another
-     void copyEnabledStuff(const ClpSimplex * rhs);
-     //@}
-
-     /**@name most useful gets and sets */
-     //@{
-     /// If problem is primal feasible
-     inline bool primalFeasible() const {
-          return (numberPrimalInfeasibilities_ == 0);
-     }
-     /// If problem is dual feasible
-     inline bool dualFeasible() const {
-          return (numberDualInfeasibilities_ == 0);
-     }
-     /// factorization
-     inline ClpFactorization * factorization() const {
-          return factorization_;
-     }
-     /// Sparsity on or off
-     bool sparseFactorization() const;
-     void setSparseFactorization(bool value);
-     /// Factorization frequency
-     int factorizationFrequency() const;
-     void setFactorizationFrequency(int value);
-     /// Dual bound
-     inline double dualBound() const {
-          return dualBound_;
-     }
-     void setDualBound(double value);
-     /// Infeasibility cost
-     inline double infeasibilityCost() const {
-          return infeasibilityCost_;
-     }
-     void setInfeasibilityCost(double value);
-     /** Amount of print out:
-         0 - none
-         1 - just final
-         2 - just factorizations
-         3 - as 2 plus a bit more
-         4 - verbose
-         above that 8,16,32 etc just for selective debug
-     */
-     /** Perturbation:
-         50  - switch on perturbation
-         100 - auto perturb if takes too long (1.0e-6 largest nonzero)
-         101 - we are perturbed
-         102 - don't try perturbing again
-         default is 100
-         others are for playing
-     */
-     inline int perturbation() const {
-          return perturbation_;
-     }
-     void setPerturbation(int value);
-     /// Current (or last) algorithm
-     inline int algorithm() const {
-          return algorithm_;
-     }
-     /// Set algorithm
-     inline void setAlgorithm(int value) {
-          algorithm_ = value;
-     }
-     /// Return true if the objective limit test can be relied upon
-     bool isObjectiveLimitTestValid() const ;
-     /// Sum of dual infeasibilities
-     inline double sumDualInfeasibilities() const {
-          return sumDualInfeasibilities_;
-     }
-     inline void setSumDualInfeasibilities(double value) {
-          sumDualInfeasibilities_ = value;
-     }
-     /// Sum of relaxed dual infeasibilities
-     inline double sumOfRelaxedDualInfeasibilities() const {
-          return sumOfRelaxedDualInfeasibilities_;
-     }
-     inline void setSumOfRelaxedDualInfeasibilities(double value) {
-          sumOfRelaxedDualInfeasibilities_ = value;
-     }
-     /// Number of dual infeasibilities
-     inline int numberDualInfeasibilities() const {
-          return numberDualInfeasibilities_;
-     }
-     inline void setNumberDualInfeasibilities(int value) {
-          numberDualInfeasibilities_ = value;
-     }
-     /// Number of dual infeasibilities (without free)
-     inline int numberDualInfeasibilitiesWithoutFree() const {
-          return numberDualInfeasibilitiesWithoutFree_;
-     }
-     /// Sum of primal infeasibilities
-     inline double sumPrimalInfeasibilities() const {
-          return sumPrimalInfeasibilities_;
-     }
-     inline void setSumPrimalInfeasibilities(double value) {
-          sumPrimalInfeasibilities_ = value;
-     }
-     /// Sum of relaxed primal infeasibilities
-     inline double sumOfRelaxedPrimalInfeasibilities() const {
-          return sumOfRelaxedPrimalInfeasibilities_;
-     }
-     inline void setSumOfRelaxedPrimalInfeasibilities(double value) {
-          sumOfRelaxedPrimalInfeasibilities_ = value;
-     }
-     /// Number of primal infeasibilities
-     inline int numberPrimalInfeasibilities() const {
-          return numberPrimalInfeasibilities_;
-     }
-     inline void setNumberPrimalInfeasibilities(int value) {
-          numberPrimalInfeasibilities_ = value;
-     }
-     /** Save model to file, returns 0 if success.  This is designed for
-         use outside algorithms so does not save iterating arrays etc.
-     It does not save any messaging information.
-     Does not save scaling values.
-     It does not know about all types of virtual functions.
-     */
-     int saveModel(const char * fileName);
-     /** Restore model from file, returns 0 if success,
-         deletes current model */
-     int restoreModel(const char * fileName);
-
-     /** Just check solution (for external use) - sets sum of
-         infeasibilities etc.
-         If setToBounds 0 then primal column values not changed
-         and used to compute primal row activity values.  If 1 or 2
-         then status used - so all nonbasic variables set to
-         indicated bound and if any values changed (or ==2)  basic values re-computed.
-     */
-     void checkSolution(int setToBounds = 0);
-     /** Just check solution (for internal use) - sets sum of
-         infeasibilities etc. */
-     void checkSolutionInternal();
-     /// Check unscaled primal solution but allow for rounding error
-     void checkUnscaledSolution();
-     /// Useful row length arrays (0,1,2,3,4,5)
-     inline CoinIndexedVector * rowArray(int index) const {
-          return rowArray_[index];
-     }
-     /// Useful column length arrays (0,1,2,3,4,5)
-     inline CoinIndexedVector * columnArray(int index) const {
-          return columnArray_[index];
-     }
-     //@}
-
-     /******************** End of most useful part **************/
-     /**@name Functions less likely to be useful to casual user */
-     //@{
-     /** Given an existing factorization computes and checks
-         primal and dual solutions.  Uses input arrays for variables at
-         bounds.  Returns feasibility states */
-     int getSolution (  const double * rowActivities,
-                        const double * columnActivities);
-     /** Given an existing factorization computes and checks
-         primal and dual solutions.  Uses current problem arrays for
-         bounds.  Returns feasibility states */
-     int getSolution ();
-     /** Constructs a non linear cost from list of non-linearities (columns only)
-         First lower of each column is taken as real lower
-         Last lower is taken as real upper and cost ignored
-
-         Returns nonzero if bad data e.g. lowers not monotonic
-     */
-     int createPiecewiseLinearCosts(const int * starts,
-                                    const double * lower, const double * gradient);
-     /// dual row pivot choice
-     inline ClpDualRowPivot * dualRowPivot() const {
-          return dualRowPivot_;
-     }
-     /// primal column pivot choice
-     inline ClpPrimalColumnPivot * primalColumnPivot() const {
-          return primalColumnPivot_;
-     }
-     /// Returns true if model looks OK
-     inline bool goodAccuracy() const {
-          return (largestPrimalError_ < 1.0e-7 && largestDualError_ < 1.0e-7);
-     }
-     /** Return model - updates any scalars */
-     void returnModel(ClpSimplex & otherModel);
-     /** Factorizes using current basis.
-         solveType - 1 iterating, 0 initial, -1 external
-         If 10 added then in primal values pass
-         Return codes are as from ClpFactorization unless initial factorization
-         when total number of singularities is returned.
-         Special case is numberRows_+1 -> all slack basis.
-     */
-     int internalFactorize(int solveType);
-     /// Save data
-     ClpDataSave saveData() ;
-     /// Restore data
-     void restoreData(ClpDataSave saved);
-     /// Clean up status
-     void cleanStatus();
-     /// Factorizes using current basis. For external use
-     int factorize();
-     /** Computes duals from scratch. If givenDjs then
-         allows for nonzero basic djs */
-     void computeDuals(double * givenDjs);
-     /// Computes primals from scratch
-     void computePrimals (  const double * rowActivities,
-                            const double * columnActivities);
-     /** Adds multiple of a column into an array */
-     void add(double * array,
-              int column, double multiplier) const;
-     /**
-        Unpacks one column of the matrix into indexed array
-        Uses sequenceIn_
-        Also applies scaling if needed
-     */
-     void unpack(CoinIndexedVector * rowArray) const ;
-     /**
-        Unpacks one column of the matrix into indexed array
-        Slack if sequence>= numberColumns
-        Also applies scaling if needed
-     */
-     void unpack(CoinIndexedVector * rowArray, int sequence) const;
-     /**
-        Unpacks one column of the matrix into indexed array
-        ** as packed vector
-        Uses sequenceIn_
-        Also applies scaling if needed
-     */
-     void unpackPacked(CoinIndexedVector * rowArray) ;
-     /**
-        Unpacks one column of the matrix into indexed array
-        ** as packed vector
-        Slack if sequence>= numberColumns
-        Also applies scaling if needed
-     */
-     void unpackPacked(CoinIndexedVector * rowArray, int sequence);
-#ifndef CLP_USER_DRIVEN
-protected:
-#endif
-     /**
-         This does basis housekeeping and does values for in/out variables.
-         Can also decide to re-factorize
-     */
-     int housekeeping(double objectiveChange);
-     /** This sets largest infeasibility and most infeasible and sum
-         and number of infeasibilities (Primal) */
-     void checkPrimalSolution(const double * rowActivities = NULL,
-                              const double * columnActivies = NULL);
-     /** This sets largest infeasibility and most infeasible and sum
-         and number of infeasibilities (Dual) */
-     void checkDualSolution();
-     /** This sets sum and number of infeasibilities (Dual and Primal) */
-     void checkBothSolutions();
-     /**  If input negative scales objective so maximum <= -value
-          and returns scale factor used.  If positive unscales and also
-          redoes dual stuff
-     */
-     double scaleObjective(double value);
-     /// Solve using Dantzig-Wolfe decomposition and maybe in parallel
-    int solveDW(CoinStructuredModel * model, ClpSolve & options);
-     /// Solve using Benders decomposition and maybe in parallel
-     int solveBenders(CoinStructuredModel * model, ClpSolve & options);
-public:
-     /** For advanced use.  When doing iterative solves things can get
-         nasty so on values pass if incoming solution has largest
-         infeasibility < incomingInfeasibility throw out variables
-         from basis until largest infeasibility < allowedInfeasibility
-         or incoming largest infeasibility.
-         If allowedInfeasibility>= incomingInfeasibility this is
-         always possible altough you may end up with an all slack basis.
-
-         Defaults are 1.0,10.0
-     */
-     void setValuesPassAction(double incomingInfeasibility,
-                              double allowedInfeasibility);
-     /** Get a clean factorization - i.e. throw out singularities
-	 may do more later */
-     int cleanFactorization(int ifValuesPass);
-     //@}
-     /**@name most useful gets and sets */
-     //@{
-public:
-     /// Initial value for alpha accuracy calculation (-1.0 off)
-     inline double alphaAccuracy() const {
-          return alphaAccuracy_;
-     }
-     inline void setAlphaAccuracy(double value) {
-          alphaAccuracy_ = value;
-     }
-public:
-     /// Objective value
-     //inline double objectiveValue() const {
-     //return (objectiveValue_-bestPossibleImprovement_)*optimizationDirection_ - dblParam_[ClpObjOffset];
-     //}
-     /// Set disaster handler
-     inline void setDisasterHandler(ClpDisasterHandler * handler) {
-          disasterArea_ = handler;
-     }
-     /// Get disaster handler
-     inline ClpDisasterHandler * disasterHandler() const {
-          return disasterArea_;
-     }
-     /// Large bound value (for complementarity etc)
-     inline double largeValue() const {
-          return largeValue_;
-     }
-     void setLargeValue( double value) ;
-     /// Largest error on Ax-b
-     inline double largestPrimalError() const {
-          return largestPrimalError_;
-     }
-     /// Largest error on basic duals
-     inline double largestDualError() const {
-          return largestDualError_;
-     }
-     /// Largest error on Ax-b
-     inline void setLargestPrimalError(double value) {
-          largestPrimalError_ = value;
-     }
-     /// Largest error on basic duals
-     inline void setLargestDualError(double value) {
-          largestDualError_ = value;
-     }
-     /// Get zero tolerance
-     inline double zeroTolerance() const {
-          return zeroTolerance_;/*factorization_->zeroTolerance();*/
-     }
-     /// Set zero tolerance
-     inline void setZeroTolerance( double value) {
-          zeroTolerance_ = value;
-     }
-     /// Basic variables pivoting on which rows
-     inline int * pivotVariable() const {
-          return pivotVariable_;
-     }
-     /// If automatic scaling on
-     inline bool automaticScaling() const {
-          return automaticScale_ != 0;
-     }
-     inline void setAutomaticScaling(bool onOff) {
-          automaticScale_ = onOff ? 1 : 0;
-     }
-     /// Current dual tolerance
-     inline double currentDualTolerance() const {
-          return dualTolerance_;
-     }
-     inline void setCurrentDualTolerance(double value) {
-          dualTolerance_ = value;
-     }
-     /// Current primal tolerance
-     inline double currentPrimalTolerance() const {
-          return primalTolerance_;
-     }
-     inline void setCurrentPrimalTolerance(double value) {
-          primalTolerance_ = value;
-     }
-     /// How many iterative refinements to do
-     inline int numberRefinements() const {
-          return numberRefinements_;
-     }
-     void setNumberRefinements( int value) ;
-     /// Alpha (pivot element) for use by classes e.g. steepestedge
-     inline double alpha() const {
-          return alpha_;
-     }
-     inline void setAlpha(double value) {
-          alpha_ = value;
-     }
-     /// Reduced cost of last incoming for use by classes e.g. steepestedge
-     inline double dualIn() const {
-          return dualIn_;
-     }
-     /// Set reduced cost of last incoming to force error
-     inline void setDualIn(double value) {
-          dualIn_ = value;
-     }
-     /// Pivot Row for use by classes e.g. steepestedge
-     inline int pivotRow() const {
-          return pivotRow_;
-     }
-     inline void setPivotRow(int value) {
-          pivotRow_ = value;
-     }
-     /// value of incoming variable (in Dual)
-     double valueIncomingDual() const;
-     //@}
-
-#ifndef CLP_USER_DRIVEN
-protected:
-#endif
-     /**@name protected methods */
-     //@{
-     /** May change basis and then returns number changed.
-         Computation of solutions may be overriden by given pi and solution
-     */
-     int gutsOfSolution ( double * givenDuals,
-                          const double * givenPrimals,
-                          bool valuesPass = false);
-     /// Does most of deletion (0 = all, 1 = most, 2 most + factorization)
-     void gutsOfDelete(int type);
-     /// Does most of copying
-     void gutsOfCopy(const ClpSimplex & rhs);
-     /** puts in format I like (rowLower,rowUpper) also see StandardMatrix
-         1 bit does rows (now and columns), (2 bit does column bounds), 4 bit does objective(s).
-         8 bit does solution scaling in
-         16 bit does rowArray and columnArray indexed vectors
-         and makes row copy if wanted, also sets columnStart_ etc
-         Also creates scaling arrays if needed.  It does scaling if needed.
-         16 also moves solutions etc in to work arrays
-         On 16 returns false if problem "bad" i.e. matrix or bounds bad
-         If startFinishOptions is -1 then called by user in getSolution
-         so do arrays but keep pivotVariable_
-     */
-     bool createRim(int what, bool makeRowCopy = false, int startFinishOptions = 0);
-     /// Does rows and columns
-     void createRim1(bool initial);
-     /// Does objective
-     void createRim4(bool initial);
-     /// Does rows and columns and objective
-     void createRim5(bool initial);
-     /** releases above arrays and does solution scaling out.  May also
-         get rid of factorization data -
-         0 get rid of nothing, 1 get rid of arrays, 2 also factorization
-     */
-     void deleteRim(int getRidOfFactorizationData = 2);
-     /// Sanity check on input rim data (after scaling) - returns true if okay
-     bool sanityCheck();
-     //@}
-public:
-     /**@name public methods */
-     //@{
-     /** Return row or column sections - not as much needed as it
-         once was.  These just map into single arrays */
-     inline double * solutionRegion(int section) const {
-          if (!section) return rowActivityWork_;
-          else return columnActivityWork_;
-     }
-     inline double * djRegion(int section) const {
-          if (!section) return rowReducedCost_;
-          else return reducedCostWork_;
-     }
-     inline double * lowerRegion(int section) const {
-          if (!section) return rowLowerWork_;
-          else return columnLowerWork_;
-     }
-     inline double * upperRegion(int section) const {
-          if (!section) return rowUpperWork_;
-          else return columnUpperWork_;
-     }
-     inline double * costRegion(int section) const {
-          if (!section) return rowObjectiveWork_;
-          else return objectiveWork_;
-     }
-     /// Return region as single array
-     inline double * solutionRegion() const {
-          return solution_;
-     }
-     inline double * djRegion() const {
-          return dj_;
-     }
-     inline double * lowerRegion() const {
-          return lower_;
-     }
-     inline double * upperRegion() const {
-          return upper_;
-     }
-     inline double * costRegion() const {
-          return cost_;
-     }
-     inline Status getStatus(int sequence) const {
-          return static_cast<Status> (status_[sequence] & 7);
-     }
-     inline void setStatus(int sequence, Status newstatus) {
-          unsigned char & st_byte = status_[sequence];
-          st_byte = static_cast<unsigned char>(st_byte & ~7);
-          st_byte = static_cast<unsigned char>(st_byte | newstatus);
-     }
-     /// Start or reset using maximumRows_ and Columns_ - true if change
-     bool startPermanentArrays();
-     /** Normally the first factorization does sparse coding because
-         the factorization could be singular.  This allows initial dense
-         factorization when it is known to be safe
-     */
-     void setInitialDenseFactorization(bool onOff);
-     bool  initialDenseFactorization() const;
-     /** Return sequence In or Out */
-     inline int sequenceIn() const {
-          return sequenceIn_;
-     }
-     inline int sequenceOut() const {
-          return sequenceOut_;
-     }
-     /** Set sequenceIn or Out */
-     inline void  setSequenceIn(int sequence) {
-          sequenceIn_ = sequence;
-     }
-     inline void  setSequenceOut(int sequence) {
-          sequenceOut_ = sequence;
-     }
-     /** Return direction In or Out */
-     inline int directionIn() const {
-          return directionIn_;
-     }
-     inline int directionOut() const {
-          return directionOut_;
-     }
-     /** Set directionIn or Out */
-     inline void  setDirectionIn(int direction) {
-          directionIn_ = direction;
-     }
-     inline void  setDirectionOut(int direction) {
-          directionOut_ = direction;
-     }
-     /// Value of Out variable
-     inline double valueOut() const {
-          return valueOut_;
-     }
-     /// Set value of out variable
-     inline void setValueOut(double value) {
-          valueOut_ = value;
-     }
-     /// Dual value of Out variable
-     inline double dualOut() const {
-          return dualOut_;
-     }
-     /// Set dual value of out variable
-     inline void setDualOut(double value) {
-          dualOut_ = value;
-     }
-     /// Set lower of out variable
-     inline void setLowerOut(double value) {
-          lowerOut_ = value;
-     }
-     /// Set upper of out variable
-     inline void setUpperOut(double value) {
-          upperOut_ = value;
-     }
-     /// Set theta of out variable
-     inline void setTheta(double value) {
-          theta_ = value;
-     }
-     /// Returns 1 if sequence indicates column
-     inline int isColumn(int sequence) const {
-          return sequence < numberColumns_ ? 1 : 0;
-     }
-     /// Returns sequence number within section
-     inline int sequenceWithin(int sequence) const {
-          return sequence < numberColumns_ ? sequence : sequence - numberColumns_;
-     }
-     /// Return row or column values
-     inline double solution(int sequence) {
-          return solution_[sequence];
-     }
-     /// Return address of row or column values
-     inline double & solutionAddress(int sequence) {
-          return solution_[sequence];
-     }
-     inline double reducedCost(int sequence) {
-          return dj_[sequence];
-     }
-     inline double & reducedCostAddress(int sequence) {
-          return dj_[sequence];
-     }
-     inline double lower(int sequence) {
-          return lower_[sequence];
-     }
-     /// Return address of row or column lower bound
-     inline double & lowerAddress(int sequence) {
-          return lower_[sequence];
-     }
-     inline double upper(int sequence) {
-          return upper_[sequence];
-     }
-     /// Return address of row or column upper bound
-     inline double & upperAddress(int sequence) {
-          return upper_[sequence];
-     }
-     inline double cost(int sequence) {
-          return cost_[sequence];
-     }
-     /// Return address of row or column cost
-     inline double & costAddress(int sequence) {
-          return cost_[sequence];
-     }
-     /// Return original lower bound
-     inline double originalLower(int iSequence) const {
-          if (iSequence < numberColumns_) return columnLower_[iSequence];
-          else
-               return rowLower_[iSequence-numberColumns_];
-     }
-     /// Return original lower bound
-     inline double originalUpper(int iSequence) const {
-          if (iSequence < numberColumns_) return columnUpper_[iSequence];
-          else
-               return rowUpper_[iSequence-numberColumns_];
-     }
-     /// Theta (pivot change)
-     inline double theta() const {
-          return theta_;
-     }
-     /** Best possible improvement using djs (primal) or
-         obj change by flipping bounds to make dual feasible (dual) */
-     inline double bestPossibleImprovement() const {
-          return bestPossibleImprovement_;
-     }
-     /// Return pointer to details of costs
-     inline ClpNonLinearCost * nonLinearCost() const {
-          return nonLinearCost_;
-     }
-     /** Return more special options
-         1 bit - if presolve says infeasible in ClpSolve return
-         2 bit - if presolved problem infeasible return
-         4 bit - keep arrays like upper_ around
-         8 bit - if factorization kept can still declare optimal at once
-         16 bit - if checking replaceColumn accuracy before updating
-         32 bit - say optimal if primal feasible!
-         64 bit - give up easily in dual (and say infeasible)
-         128 bit - no objective, 0-1 and in B&B
-         256 bit - in primal from dual or vice versa
-         512 bit - alternative use of solveType_
-         1024 bit - don't do row copy of factorization
-	 2048 bit - perturb in complete fathoming
-	 4096 bit - try more for complete fathoming
-	 8192 bit - don't even think of using primal if user asks for dual (and vv)
-	 16384 bit - in initialSolve so be more flexible
-	 32768 bit - don't swap algorithms from dual if small infeasibility
-	 65536 bit - perturb in postsolve cleanup (even if < 10000 rows)
-	 131072 bit (*3) initial stateDualColumn
-	 524288 bit - stop when primal feasible
-     */
-     inline int moreSpecialOptions() const {
-          return moreSpecialOptions_;
-     }
-     /** Set more special options
-         1 bit - if presolve says infeasible in ClpSolve return
-         2 bit - if presolved problem infeasible return
-         4 bit - keep arrays like upper_ around
-         8 bit - no free or superBasic variables
-         16 bit - if checking replaceColumn accuracy before updating
-         32 bit - say optimal if primal feasible!
-         64 bit - give up easily in dual (and say infeasible)
-         128 bit - no objective, 0-1 and in B&B
-         256 bit - in primal from dual or vice versa
-         512 bit - alternative use of solveType_
-         1024 bit - don't do row copy of factorization
-	 2048 bit - perturb in complete fathoming
-	 4096 bit - try more for complete fathoming
-	 8192 bit - don't even think of using primal if user asks for dual (and vv)
-	 16384 bit - in initialSolve so be more flexible
-	 32768 bit - don't swap algorithms from dual if small infeasibility
-	 65536 bit - perturb in postsolve cleanup (even if < 10000 rows)
-	 131072 bit (*3) initial stateDualColumn
-	 524288 bit - stop when primal feasible
-	 1048576 bit - don't perturb even if long time
-	 2097152 bit - no primal in fastDual2 if feasible
-	 4194304 bit - tolerances have been changed by code
-	 8388608 bit - tolerances are dynamic (at first)
-     */
-     inline void setMoreSpecialOptions(int value) {
-          moreSpecialOptions_ = value;
-     }
-     //@}
-     /**@name status methods */
-     //@{
-     inline void setFakeBound(int sequence, FakeBound fakeBound) {
-          unsigned char & st_byte = status_[sequence];
-          st_byte = static_cast<unsigned char>(st_byte & ~24);
-          st_byte = static_cast<unsigned char>(st_byte | (fakeBound << 3));
-     }
-     inline FakeBound getFakeBound(int sequence) const {
-          return static_cast<FakeBound> ((status_[sequence] >> 3) & 3);
-     }
-     inline void setRowStatus(int sequence, Status newstatus) {
-          unsigned char & st_byte = status_[sequence+numberColumns_];
-          st_byte = static_cast<unsigned char>(st_byte & ~7);
-          st_byte = static_cast<unsigned char>(st_byte | newstatus);
-     }
-     inline Status getRowStatus(int sequence) const {
-          return static_cast<Status> (status_[sequence+numberColumns_] & 7);
-     }
-     inline void setColumnStatus(int sequence, Status newstatus) {
-          unsigned char & st_byte = status_[sequence];
-          st_byte = static_cast<unsigned char>(st_byte & ~7);
-          st_byte = static_cast<unsigned char>(st_byte | newstatus);
-     }
-     inline Status getColumnStatus(int sequence) const {
-          return static_cast<Status> (status_[sequence] & 7);
-     }
-     inline void setPivoted( int sequence) {
-          status_[sequence] = static_cast<unsigned char>(status_[sequence] | 32);
-     }
-     inline void clearPivoted( int sequence) {
-          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~32);
-     }
-     inline bool pivoted(int sequence) const {
-          return (((status_[sequence] >> 5) & 1) != 0);
-     }
-     /// To flag a variable (not inline to allow for column generation)
-     void setFlagged( int sequence);
-     inline void clearFlagged( int sequence) {
-          status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~64);
-     }
-     inline bool flagged(int sequence) const {
-          return ((status_[sequence] & 64) != 0);
-     }
-     /// To say row active in primal pivot row choice
-     inline void setActive( int iRow) {
-          status_[iRow] = static_cast<unsigned char>(status_[iRow] | 128);
-     }
-     inline void clearActive( int iRow) {
-          status_[iRow] = static_cast<unsigned char>(status_[iRow] & ~128);
-     }
-     inline bool active(int iRow) const {
-          return ((status_[iRow] & 128) != 0);
-     }
-     /// To say perturbed 
-     inline void setPerturbed( int iSequence) {
-          status_[iSequence] = static_cast<unsigned char>(status_[iSequence] | 128);
-     }
-     inline void clearPerturbed( int iSequence) {
-          status_[iSequence] = static_cast<unsigned char>(status_[iSequence] & ~128);
-     }
-     inline bool perturbed(int iSequence) const {
-          return ((status_[iSequence] & 128) != 0);
-     }
-     /** Set up status array (can be used by OsiClp).
-         Also can be used to set up all slack basis */
-     void createStatus() ;
-     /** Sets up all slack basis and resets solution to
-         as it was after initial load or readMps */
-     void allSlackBasis(bool resetSolution = false);
-
-     /// So we know when to be cautious
-     inline int lastBadIteration() const {
-          return lastBadIteration_;
-     }
-     /// Set so we know when to be cautious
-     inline void setLastBadIteration(int value) {
-          lastBadIteration_=value;
-     }
-     /// Progress flag - at present 0 bit says artificials out
-     inline int progressFlag() const {
-          return (progressFlag_ & 3);
-     }
-     /// For dealing with all issues of cycling etc
-     inline ClpSimplexProgress * progress()
-     { return &progress_;}
-     /// Force re-factorization early value
-     inline int forceFactorization() const {
-          return forceFactorization_ ;
-     }
-     /// Force re-factorization early
-     inline void forceFactorization(int value) {
-          forceFactorization_ = value;
-     }
-     /// Raw objective value (so always minimize in primal)
-     inline double rawObjectiveValue() const {
-          return objectiveValue_;
-     }
-     /// Compute objective value from solution and put in objectiveValue_
-     void computeObjectiveValue(bool useWorkingSolution = false);
-     /// Compute minimization objective value from internal solution without perturbation
-     double computeInternalObjectiveValue();
-     /** Infeasibility/unbounded ray (NULL returned if none/wrong)
-         Up to user to use delete [] on these arrays.  */
-     double * infeasibilityRay(bool fullRay=false) const;
-     /** Number of extra rows.  These are ones which will be dynamically created
-         each iteration.  This is for GUB but may have other uses.
-     */
-     inline int numberExtraRows() const {
-          return numberExtraRows_;
-     }
-     /** Maximum number of basic variables - can be more than number of rows if GUB
-     */
-     inline int maximumBasic() const {
-          return maximumBasic_;
-     }
-     /// Iteration when we entered dual or primal
-     inline int baseIteration() const {
-          return baseIteration_;
-     }
-     /// Create C++ lines to get to current state
-     void generateCpp( FILE * fp, bool defaultFactor = false);
-     /// Gets clean and emptyish factorization
-     ClpFactorization * getEmptyFactorization();
-     /// May delete or may make clean and emptyish factorization
-     void setEmptyFactorization();
-     /// Move status and solution across
-     void moveInfo(const ClpSimplex & rhs, bool justStatus = false);
-     //@}
-
-     ///@name Basis handling
-     // These are only to be used using startFinishOptions (ClpSimplexDual, ClpSimplexPrimal)
-     // *** At present only without scaling
-     // *** Slacks havve -1.0 element (so == row activity) - take care
-     ///Get a row of the tableau (slack part in slack if not NULL)
-     void getBInvARow(int row, double* z, double * slack = NULL);
-
-     ///Get a row of the basis inverse
-     void getBInvRow(int row, double* z);
-
-     ///Get a column of the tableau
-     void getBInvACol(int col, double* vec);
-
-     ///Get a column of the basis inverse
-     void getBInvCol(int col, double* vec);
-
-     /** Get basic indices (order of indices corresponds to the
-         order of elements in a vector retured by getBInvACol() and
-         getBInvCol()).
-     */
-     void getBasics(int* index);
-
-     //@}
-     //-------------------------------------------------------------------------
-     /**@name Changing bounds on variables and constraints */
-     //@{
-     /** Set an objective function coefficient */
-     void setObjectiveCoefficient( int elementIndex, double elementValue );
-     /** Set an objective function coefficient */
-     inline void setObjCoeff( int elementIndex, double elementValue ) {
-          setObjectiveCoefficient( elementIndex, elementValue);
-     }
-
-     /** Set a single column lower bound<br>
-         Use -DBL_MAX for -infinity. */
-     void setColumnLower( int elementIndex, double elementValue );
-
-     /** Set a single column upper bound<br>
-         Use DBL_MAX for infinity. */
-     void setColumnUpper( int elementIndex, double elementValue );
-
-     /** Set a single column lower and upper bound */
-     void setColumnBounds( int elementIndex,
-                           double lower, double upper );
-
-     /** Set the bounds on a number of columns simultaneously<br>
-         The default implementation just invokes setColLower() and
-         setColUpper() over and over again.
-         @param indexFirst,indexLast pointers to the beginning and after the
-            end of the array of the indices of the variables whose
-        <em>either</em> bound changes
-         @param boundList the new lower/upper bound pairs for the variables
-     */
-     void setColumnSetBounds(const int* indexFirst,
-                             const int* indexLast,
-                             const double* boundList);
-
-     /** Set a single column lower bound<br>
-         Use -DBL_MAX for -infinity. */
-     inline void setColLower( int elementIndex, double elementValue ) {
-          setColumnLower(elementIndex, elementValue);
-     }
-     /** Set a single column upper bound<br>
-         Use DBL_MAX for infinity. */
-     inline void setColUpper( int elementIndex, double elementValue ) {
-          setColumnUpper(elementIndex, elementValue);
-     }
-
-     /** Set a single column lower and upper bound */
-     inline void setColBounds( int elementIndex,
-                               double newlower, double newupper ) {
-          setColumnBounds(elementIndex, newlower, newupper);
-     }
-
-     /** Set the bounds on a number of columns simultaneously<br>
-         @param indexFirst,indexLast pointers to the beginning and after the
-            end of the array of the indices of the variables whose
-        <em>either</em> bound changes
-         @param boundList the new lower/upper bound pairs for the variables
-     */
-     inline void setColSetBounds(const int* indexFirst,
-                                 const int* indexLast,
-                                 const double* boundList) {
-          setColumnSetBounds(indexFirst, indexLast, boundList);
-     }
-
-     /** Set a single row lower bound<br>
-         Use -DBL_MAX for -infinity. */
-     void setRowLower( int elementIndex, double elementValue );
-
-     /** Set a single row upper bound<br>
-         Use DBL_MAX for infinity. */
-     void setRowUpper( int elementIndex, double elementValue ) ;
-
-     /** Set a single row lower and upper bound */
-     void setRowBounds( int elementIndex,
-                        double lower, double upper ) ;
-
-     /** Set the bounds on a number of rows simultaneously<br>
-         @param indexFirst,indexLast pointers to the beginning and after the
-            end of the array of the indices of the constraints whose
-        <em>either</em> bound changes
-         @param boundList the new lower/upper bound pairs for the constraints
-     */
-     void setRowSetBounds(const int* indexFirst,
-                          const int* indexLast,
-                          const double* boundList);
-     /// Resizes rim part of model
-     void resize (int newNumberRows, int newNumberColumns);
-
-     //@}
-
-////////////////// data //////////////////
-protected:
-
-     /**@name data.  Many arrays have a row part and a column part.
-      There is a single array with both - columns then rows and
-      then normally two arrays pointing to rows and columns.  The
-      single array is the owner of memory
-     */
-     //@{
-     /** Best possible improvement using djs (primal) or
-         obj change by flipping bounds to make dual feasible (dual) */
-     double bestPossibleImprovement_;
-     /// Zero tolerance
-     double zeroTolerance_;
-     /// Sequence of worst (-1 if feasible)
-     int columnPrimalSequence_;
-     /// Sequence of worst (-1 if feasible)
-     int rowPrimalSequence_;
-     /// "Best" objective value
-     double bestObjectiveValue_;
-     /// More special options - see set for details
-     int moreSpecialOptions_;
-     /// Iteration when we entered dual or primal
-     int baseIteration_;
-     /// Primal tolerance needed to make dual feasible (<largeTolerance)
-     double primalToleranceToGetOptimal_;
-     /// Large bound value (for complementarity etc)
-     double largeValue_;
-     /// Largest error on Ax-b
-     double largestPrimalError_;
-     /// Largest error on basic duals
-     double largestDualError_;
-     /// For computing whether to re-factorize
-     double alphaAccuracy_;
-     /// Dual bound
-     double dualBound_;
-     /// Alpha (pivot element)
-     double alpha_;
-     /// Theta (pivot change)
-     double theta_;
-     /// Lower Bound on In variable
-     double lowerIn_;
-     /// Value of In variable
-     double valueIn_;
-     /// Upper Bound on In variable
-     double upperIn_;
-     /// Reduced cost of In variable
-     double dualIn_;
-     /// Lower Bound on Out variable
-     double lowerOut_;
-     /// Value of Out variable
-     double valueOut_;
-     /// Upper Bound on Out variable
-     double upperOut_;
-     /// Infeasibility (dual) or ? (primal) of Out variable
-     double dualOut_;
-     /// Current dual tolerance for algorithm
-     double dualTolerance_;
-     /// Current primal tolerance for algorithm
-     double primalTolerance_;
-     /// Sum of dual infeasibilities
-     double sumDualInfeasibilities_;
-     /// Sum of primal infeasibilities
-     double sumPrimalInfeasibilities_;
-     /// Weight assigned to being infeasible in primal
-     double infeasibilityCost_;
-     /// Sum of Dual infeasibilities using tolerance based on error in duals
-     double sumOfRelaxedDualInfeasibilities_;
-     /// Sum of Primal infeasibilities using tolerance based on error in primals
-     double sumOfRelaxedPrimalInfeasibilities_;
-     /// Acceptable pivot value just after factorization
-     double acceptablePivot_;
-     /// Minimum primal tolerance
-     double minimumPrimalTolerance_;
-     /// Last few infeasibilities
-#define CLP_INFEAS_SAVE 5
-     double averageInfeasibility_[CLP_INFEAS_SAVE];
-     /// Working copy of lower bounds (Owner of arrays below)
-     double * lower_;
-     /// Row lower bounds - working copy
-     double * rowLowerWork_;
-     /// Column lower bounds - working copy
-     double * columnLowerWork_;
-     /// Working copy of upper bounds (Owner of arrays below)
-     double * upper_;
-     /// Row upper bounds - working copy
-     double * rowUpperWork_;
-     /// Column upper bounds - working copy
-     double * columnUpperWork_;
-     /// Working copy of objective (Owner of arrays below)
-     double * cost_;
-     /// Row objective - working copy
-     double * rowObjectiveWork_;
-     /// Column objective - working copy
-     double * objectiveWork_;
-     /// Useful row length arrays
-     CoinIndexedVector * rowArray_[6];
-     /// Useful column length arrays
-     CoinIndexedVector * columnArray_[6];
-     /// Sequence of In variable
-     int sequenceIn_;
-     /// Direction of In, 1 going up, -1 going down, 0 not a clude
-     int directionIn_;
-     /// Sequence of Out variable
-     int sequenceOut_;
-     /// Direction of Out, 1 to upper bound, -1 to lower bound, 0 - superbasic
-     int directionOut_;
-     /// Pivot Row
-     int pivotRow_;
-     /// Last good iteration (immediately after a re-factorization)
-     int lastGoodIteration_;
-     /// Working copy of reduced costs (Owner of arrays below)
-     double * dj_;
-     /// Reduced costs of slacks not same as duals (or - duals)
-     double * rowReducedCost_;
-     /// Possible scaled reduced costs
-     double * reducedCostWork_;
-     /// Working copy of primal solution (Owner of arrays below)
-     double * solution_;
-     /// Row activities - working copy
-     double * rowActivityWork_;
-     /// Column activities - working copy
-     double * columnActivityWork_;
-     /// Number of dual infeasibilities
-     int numberDualInfeasibilities_;
-     /// Number of dual infeasibilities (without free)
-     int numberDualInfeasibilitiesWithoutFree_;
-     /// Number of primal infeasibilities
-     int numberPrimalInfeasibilities_;
-     /// How many iterative refinements to do
-     int numberRefinements_;
-     /// dual row pivot choice
-     ClpDualRowPivot * dualRowPivot_;
-     /// primal column pivot choice
-     ClpPrimalColumnPivot * primalColumnPivot_;
-     /// Basic variables pivoting on which rows
-     int * pivotVariable_;
-     /// factorization
-     ClpFactorization * factorization_;
-     /// Saved version of solution
-     double * savedSolution_;
-     /// Number of times code has tentatively thought optimal
-     int numberTimesOptimal_;
-     /// Disaster handler
-     ClpDisasterHandler * disasterArea_;
-     /// If change has been made (first attempt at stopping looping)
-     int changeMade_;
-     /// Algorithm >0 == Primal, <0 == Dual
-     int algorithm_;
-     /** Now for some reliability aids
-         This forces re-factorization early */
-     int forceFactorization_;
-     /** Perturbation:
-         -50 to +50 - perturb by this power of ten (-6 sounds good)
-         100 - auto perturb if takes too long (1.0e-6 largest nonzero)
-         101 - we are perturbed
-         102 - don't try perturbing again
-         default is 100
-     */
-     int perturbation_;
-     /// Saved status regions
-     unsigned char * saveStatus_;
-     /** Very wasteful way of dealing with infeasibilities in primal.
-         However it will allow non-linearities and use of dual
-         analysis.  If it doesn't work it can easily be replaced.
-     */
-     ClpNonLinearCost * nonLinearCost_;
-     /// So we know when to be cautious
-     int lastBadIteration_;
-     /// So we know when to open up again
-     int lastFlaggedIteration_;
-     /// Can be used for count of fake bounds (dual) or fake costs (primal)
-     int numberFake_;
-     /// Can be used for count of changed costs (dual) or changed bounds (primal)
-     int numberChanged_;
-     /// Progress flag - at present 0 bit says artificials out, 1 free in
-     int progressFlag_;
-     /// First free/super-basic variable (-1 if none)
-     int firstFree_;
-     /** Number of extra rows.  These are ones which will be dynamically created
-         each iteration.  This is for GUB but may have other uses.
-     */
-     int numberExtraRows_;
-     /** Maximum number of basic variables - can be more than number of rows if GUB
-     */
-     int maximumBasic_;
-     /// If may skip final factorize then allow up to this pivots (default 20)
-     int dontFactorizePivots_;
-     /** For advanced use.  When doing iterative solves things can get
-         nasty so on values pass if incoming solution has largest
-         infeasibility < incomingInfeasibility throw out variables
-         from basis until largest infeasibility < allowedInfeasibility.
-         if allowedInfeasibility>= incomingInfeasibility this is
-         always possible altough you may end up with an all slack basis.
-
-         Defaults are 1.0,10.0
-     */
-     double incomingInfeasibility_;
-     double allowedInfeasibility_;
-     /// Automatic scaling of objective and rhs and bounds
-     int automaticScale_;
-     /// Maximum perturbation array size (take out when code rewritten)
-     int maximumPerturbationSize_;
-     /// Perturbation array (maximumPerturbationSize_)
-     double * perturbationArray_;
-     /// A copy of model with certain state - normally without cuts
-     ClpSimplex * baseModel_;
-     /// For dealing with all issues of cycling etc
-     ClpSimplexProgress progress_;
-#ifdef ABC_INHERIT
-  AbcSimplex * abcSimplex_;
-#define CLP_ABC_WANTED 1
-#define CLP_ABC_WANTED_PARALLEL 2
-#define CLP_ABC_FULL_DONE 8
-  // bits 256,512,1024 for crash
-#endif
-#define CLP_ABC_BEEN_FEASIBLE 65536
-  int abcState_;
-  /// Number of degenerate pivots since last perturbed
-  int numberDegeneratePivots_;
-public:
-     /// Spare int array for passing information [0]!=0 switches on
-     mutable int spareIntArray_[4];
-     /// Spare double array for passing information [0]!=0 switches on
-     mutable double spareDoubleArray_[4];
-protected:
-     /// Allow OsiClp certain perks
-     friend class OsiClpSolverInterface;
-     /// And OsiCLP
-     friend class OsiCLPSolverInterface;
-     //@}
-};
-//#############################################################################
-/** A function that tests the methods in the ClpSimplex class. The
-    only reason for it not to be a member method is that this way it doesn't
-    have to be compiled into the library. And that's a gain, because the
-    library should be compiled with optimization on, but this method should be
-    compiled with debugging.
-
-    It also does some testing of ClpFactorization class
- */
-void
-ClpSimplexUnitTest(const std::string & mpsDir);
-
-// For Devex stuff
-#define DEVEX_TRY_NORM 1.0e-4
-#define DEVEX_ADD_ONE 1.0
-#if defined(ABC_INHERIT) || defined(CBC_THREAD) || defined(THREADS_IN_ANALYZE)
-// Use pthreads
-#include <pthread.h>
-typedef struct {
-  double result;
-  //const CoinIndexedVector * constVector; // can get rid of
-  //CoinIndexedVector * vectors[2]; // can get rid of
-  void * extraInfo;
-  void * extraInfo2;
-  int status;
-  int stuff[4];
-} CoinThreadInfo;
-class CoinPthreadStuff {
-public:
-  /**@name Constructors and destructor and copy */
-  //@{
-  /** Main constructor
-  */
-  CoinPthreadStuff (int numberThreads=0,
-		    void * parallelManager(void * stuff)=NULL);
-  /// Assignment operator. This copies the data
-  CoinPthreadStuff & operator=(const CoinPthreadStuff & rhs);
-  /// Destructor
-  ~CoinPthreadStuff (  );
-  /// set stop start
-  inline void setStopStart(int value)
-  { stopStart_=value;}
-#ifndef NUMBER_THREADS 
-#define NUMBER_THREADS 8
-#endif
-  // For waking up thread
-  inline pthread_mutex_t * mutexPointer(int which,int thread=0) 
-  { return mutex_+which+3*thread;}
-#ifdef PTHREAD_BARRIER_SERIAL_THREAD
-  inline pthread_barrier_t * barrierPointer() 
-  { return &barrier_;}
-#endif
-  inline int whichLocked(int thread=0) const
-  { return locked_[thread];}
-  inline CoinThreadInfo * threadInfoPointer(int thread=0) 
-  { return threadInfo_+thread;}
-  void startParallelTask(int type,int iThread,void * info=NULL);
-  int waitParallelTask(int type, int & iThread,bool allowIdle);
-  void waitAllTasks();
-  /// so thread can find out which one it is 
-  int whichThread() const;
-  void sayIdle(int iThread);
-  //void startThreads(int numberThreads);
-  //void stopThreads();
-  // For waking up thread
-  pthread_mutex_t mutex_[3*(NUMBER_THREADS+1)];
-#ifdef PTHREAD_BARRIER_SERIAL_THREAD
-  pthread_barrier_t barrier_; 
-#endif
-  CoinThreadInfo threadInfo_[NUMBER_THREADS+1];
-  pthread_t abcThread_[NUMBER_THREADS+1];
-  int locked_[NUMBER_THREADS+1];
-  int stopStart_;
-  int numberThreads_;
-};
-void * clp_parallelManager(void * stuff);
-#endif
-#endif