source: trunk/Clp/src/OsiClp/OsiClpSolverInterface.hpp @ 1592

Last change on this file since 1592 was 1592, checked in by lou, 10 years ago

Make param of setObjectiveAndRefresh const, in case the method survives.

File size: 54.8 KB
Line 
1// Copyright (C) 2000, International Business Machines
2// Corporation and others.  All Rights Reserved.
3
4#ifndef OsiClpSolverInterface_H
5#define OsiClpSolverInterface_H
6
7#include <string>
8#include <cfloat>
9#include <map>
10
11#include "ClpSimplex.hpp"
12#include "ClpLinearObjective.hpp"
13#include "CoinPackedMatrix.hpp"
14#include "OsiSolverInterface.hpp"
15#include "CoinWarmStartBasis.hpp"
16#include "ClpEventHandler.hpp"
17#include "ClpNode.hpp"
18#include "CoinIndexedVector.hpp"
19
20class OsiRowCut;
21class OsiClpUserSolver;
22class OsiClpDisasterHandler;
23class CoinSet;
24#ifndef COIN_DBL_MAX
25static const double OsiClpInfinity = DBL_MAX;
26#else
27static const double OsiClpInfinity = COIN_DBL_MAX;
28#endif
29
30//#############################################################################
31
32/** Clp Solver Interface
33   
34Instantiation of OsiClpSolverInterface for the Model Algorithm.
35
36*/
37
38class OsiClpSolverInterface :
39  virtual public OsiSolverInterface {
40  friend int OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
41 
42public:
43  //---------------------------------------------------------------------------
44  /**@name Solve methods */
45  //@{
46  /// Solve initial LP relaxation
47  virtual void initialSolve();
48 
49  /// Resolve an LP relaxation after problem modification
50  virtual void resolve();
51 
52  /// Invoke solver's built-in enumeration algorithm
53  virtual void branchAndBound();
54
55  /** Solve when primal column and dual row solutions are near-optimal
56      options - 0 no presolve (use primal and dual)
57                1 presolve (just use primal)
58                2 no presolve (just use primal)
59      basis -   0 use all slack basis
60                1 try and put some in basis
61  */
62  void crossover(int options,int basis);
63  //@}
64 
65  ///@name OsiSimplexInterface methods
66  //@{
67 
68  /**Enables normal operation of subsequent functions.
69     This method is supposed to ensure that all typical things (like
70     reduced costs, etc.) are updated when individual pivots are executed
71     and can be queried by other methods
72  */
73  virtual void enableSimplexInterface(bool doingPrimal);
74 
75  ///Undo whatever setting changes the above method had to make
76  virtual void disableSimplexInterface();
77  /** Returns 1 if can just do getBInv etc
78      2 if has all OsiSimplex methods
79      and 0 if it has none */
80  virtual int canDoSimplexInterface() const;
81  /** Tells solver that calls to getBInv etc are about to take place.
82      Underlying code may need mutable as this may be called from
83      CglCut:;generateCuts which is const.  If that is too horrific then
84      each solver e.g. BCP or CBC will have to do something outside
85      main loop.
86  */
87  virtual void enableFactorization() const;
88  /// and stop
89  virtual void disableFactorization() const;
90 
91  /** Sets up solver for repeated use by Osi interface.
92      The normal usage does things like keeping factorization around so can be used.
93      Will also do things like keep scaling and row copy of matrix if
94      matrix does not change.
95      adventure:
96      0 - safe stuff as above
97      1 - will take more risks - if it does not work then bug which will be fixed
98      2 - don't bother doing most extreme termination checks e.g. don't bother
99      re-factorizing if less than 20 iterations.
100      3 - Actually safer than 1 (mainly just keeps factorization)
101     
102      printOut - -1 always skip round common messages instead of doing some work
103      0 skip if normal defaults
104      1 leaves
105  */
106  void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0);
107  /// Synchronize model (really if no cuts in tree)
108  virtual void synchronizeModel();
109  // Sleazy methods to fool const requirements (no less safe as modelPtr_ mutable)
110  void setSpecialOptionsMutable(unsigned int value) const;
111
112  /** Returns true if a basis is available
113      AND problem is optimal.  This should be used to see if
114      the BInvARow type operations are possible and meaningful.
115  */
116  virtual bool basisIsAvailable() const;
117 
118  /** The following two methods may be replaced by the
119      methods of OsiSolverInterface using OsiWarmStartBasis if:
120      1. OsiWarmStartBasis resize operation is implemented
121      more efficiently and
122      2. It is ensured that effects on the solver are the same
123     
124      Returns a basis status of the structural/artificial variables
125      At present as warm start i.e 0 free, 1 basic, 2 upper, 3 lower
126     
127      NOTE  artificials are treated as +1 elements so for <= rhs
128      artificial will be at lower bound if constraint is tight
129     
130      This means that Clpsimplex flips artificials as it works
131      in terms of row activities
132  */
133  virtual void getBasisStatus(int* cstat, int* rstat) const;
134 
135  /** Set the status of structural/artificial variables and
136      factorize, update solution etc
137     
138      NOTE  artificials are treated as +1 elements so for <= rhs
139      artificial will be at lower bound if constraint is tight
140     
141      This means that Clpsimplex flips artificials as it works
142      in terms of row activities
143      Returns 0 if OK, 1 if problem is bad e.g. duplicate elements, too large ...
144  */
145  virtual int setBasisStatus(const int* cstat, const int* rstat);
146 
147  /** Perform a pivot by substituting a colIn for colOut in the basis.
148      The status of the leaving variable is given in statOut. Where
149      1 is to upper bound, -1 to lower bound
150      Return code is 0 for okay,
151      1 if inaccuracy forced re-factorization (should be okay) and
152      -1 for singular factorization
153  */
154  virtual int pivot(int colIn, int colOut, int outStatus);
155 
156  /** Obtain a result of the primal pivot
157      Outputs: colOut -- leaving column, outStatus -- its status,
158      t -- step size, and, if dx!=NULL, *dx -- primal ray direction.
159      Inputs: colIn -- entering column, sign -- direction of its change (+/-1).
160      Both for colIn and colOut, artificial variables are index by
161      the negative of the row index minus 1.
162      Return code (for now): 0 -- leaving variable found,
163      -1 -- everything else?
164      Clearly, more informative set of return values is required
165      Primal and dual solutions are updated
166  */
167  virtual int primalPivotResult(int colIn, int sign, 
168                                int& colOut, int& outStatus, 
169                                double& t, CoinPackedVector* dx);
170 
171  /** Obtain a result of the dual pivot (similar to the previous method)
172      Differences: entering variable and a sign of its change are now
173      the outputs, the leaving variable and its statuts -- the inputs
174      If dx!=NULL, then *dx contains dual ray
175      Return code: same
176  */
177  virtual int dualPivotResult(int& colIn, int& sign, 
178                              int colOut, int outStatus, 
179                              double& t, CoinPackedVector* dx);
180 
181  ///Get the reduced gradient for the cost vector c
182  virtual void getReducedGradient(double* columnReducedCosts, 
183                                  double * duals,
184                                  const double * c);
185 
186  /** Set a new objective and apply the old basis so that the
187      reduced costs are properly updated  */
188  virtual void setObjectiveAndRefresh(const double* c);
189 
190  ///Get a row of the tableau (slack part in slack if not NULL)
191  virtual void getBInvARow(int row, double* z, double * slack=NULL) const;
192 
193  /** Get a row of the tableau (slack part in slack if not NULL)
194      If keepScaled is true then scale factors not applied after so
195      user has to use coding similar to what is in this method
196  */
197  virtual void getBInvARow(int row, CoinIndexedVector * z, CoinIndexedVector * slack=NULL,
198                           bool keepScaled=false) const;
199 
200  ///Get a row of the basis inverse
201  virtual void getBInvRow(int row, double* z) const;
202 
203  ///Get a column of the tableau
204  virtual void getBInvACol(int col, double* vec) const ;
205 
206  ///Get a column of the tableau
207  virtual void getBInvACol(int col, CoinIndexedVector * vec) const ;
208 
209  /** Update (i.e. ftran) the vector passed in.
210      Unscaling is applied after - can't be applied before
211  */
212 
213  virtual void getBInvACol(CoinIndexedVector * vec) const ;
214 
215  ///Get a column of the basis inverse
216  virtual void getBInvCol(int col, double* vec) const ;
217 
218  /** Get basic indices (order of indices corresponds to the
219      order of elements in a vector retured by getBInvACol() and
220      getBInvCol()).
221  */
222  virtual void getBasics(int* index) const;
223 
224  //@}
225  //---------------------------------------------------------------------------
226  /**@name Parameter set/get methods
227     
228  The set methods return true if the parameter was set to the given value,
229  false otherwise. There can be various reasons for failure: the given
230  parameter is not applicable for the solver (e.g., refactorization
231  frequency for the clp algorithm), the parameter is not yet implemented
232  for the solver or simply the value of the parameter is out of the range
233  the solver accepts. If a parameter setting call returns false check the
234  details of your solver.
235 
236  The get methods return true if the given parameter is applicable for the
237  solver and is implemented. In this case the value of the parameter is
238  returned in the second argument. Otherwise they return false.
239  */
240  //@{
241  // Set an integer parameter
242  bool setIntParam(OsiIntParam key, int value);
243  // Set an double parameter
244  bool setDblParam(OsiDblParam key, double value);
245  // Set a string parameter
246  bool setStrParam(OsiStrParam key, const std::string & value);
247  // Get an integer parameter
248  bool getIntParam(OsiIntParam key, int& value) const;
249  // Get an double parameter
250  bool getDblParam(OsiDblParam key, double& value) const;
251  // Get a string parameter
252  bool getStrParam(OsiStrParam key, std::string& value) const;
253  // Set a hint parameter - overrides OsiSolverInterface
254  virtual bool setHintParam(OsiHintParam key, bool yesNo=true,
255                            OsiHintStrength strength=OsiHintTry,
256                            void * otherInformation=NULL);
257  //@}
258 
259  //---------------------------------------------------------------------------
260  ///@name Methods returning info on how the solution process terminated
261  //@{
262  /// Are there a numerical difficulties?
263  virtual bool isAbandoned() const;
264  /// Is optimality proven?
265  virtual bool isProvenOptimal() const;
266  /// Is primal infeasiblity proven?
267  virtual bool isProvenPrimalInfeasible() const;
268  /// Is dual infeasiblity proven?
269  virtual bool isProvenDualInfeasible() const;
270  /// Is the given primal objective limit reached?
271  virtual bool isPrimalObjectiveLimitReached() const;
272  /// Is the given dual objective limit reached?
273  virtual bool isDualObjectiveLimitReached() const;
274  /// Iteration limit reached?
275  virtual bool isIterationLimitReached() const;
276  //@}
277 
278  //---------------------------------------------------------------------------
279  /**@name WarmStart related methods */
280  //@{
281 
282  /*! \brief Get an empty warm start object
283   
284  This routine returns an empty CoinWarmStartBasis object. Its purpose is
285  to provide a way to give a client a warm start basis object of the
286  appropriate type, which can resized and modified as desired.
287  */
288 
289  virtual CoinWarmStart *getEmptyWarmStart () const;
290 
291  /// Get warmstarting information
292  virtual CoinWarmStart* getWarmStart() const;
293  /// Get warmstarting information
294  inline CoinWarmStartBasis* getPointerToWarmStart() 
295  { return &basis_;}
296  /// Get warmstarting information
297  inline const CoinWarmStartBasis* getConstPointerToWarmStart() const 
298  { return &basis_;}
299  /** Set warmstarting information. Return true/false depending on whether
300      the warmstart information was accepted or not. */
301  virtual bool setWarmStart(const CoinWarmStart* warmstart);
302  /** \brief Get warm start information.
303     
304      Return warm start information for the current state of the solver
305      interface. If there is no valid warm start information, an empty warm
306      start object wil be returned.  This does not necessarily create an
307      object - may just point to one.  must Delete set true if user
308      should delete returned object.
309      OsiClp version always returns pointer and false.
310  */
311  virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ;
312
313  //@}
314 
315  //---------------------------------------------------------------------------
316  /**@name Hotstart related methods (primarily used in strong branching). <br>
317     The user can create a hotstart (a snapshot) of the optimization process
318     then reoptimize over and over again always starting from there.<br>
319     <strong>NOTE</strong>: between hotstarted optimizations only
320     bound changes are allowed. */
321  //@{
322  /// Create a hotstart point of the optimization process
323  virtual void markHotStart();
324  /// Optimize starting from the hotstart
325  virtual void solveFromHotStart();
326  /// Delete the snapshot
327  virtual void unmarkHotStart();
328  /** Start faster dual - returns negative if problems 1 if infeasible,
329      Options to pass to solver
330      1 - create external reduced costs for columns
331      2 - create external reduced costs for rows
332      4 - create external row activity (columns always done)
333      Above only done if feasible
334      When set resolve does less work
335  */
336  int startFastDual(int options);
337  /// Stop fast dual
338  void stopFastDual();
339  /// Sets integer tolerance and increment
340  void setStuff(double tolerance,double increment);
341  //@}
342 
343  //---------------------------------------------------------------------------
344  /**@name Problem information methods
345     
346  These methods call the solver's query routines to return
347  information about the problem referred to by the current object.
348  Querying a problem that has no data associated with it result in
349  zeros for the number of rows and columns, and NULL pointers from
350  the methods that return vectors.
351 
352  Const pointers returned from any data-query method are valid as
353  long as the data is unchanged and the solver is not called.
354  */
355  //@{
356  /**@name Methods related to querying the input data */
357  //@{
358  /// Get number of columns
359  virtual int getNumCols() const {
360    return modelPtr_->numberColumns(); }
361 
362  /// Get number of rows
363  virtual int getNumRows() const {
364    return modelPtr_->numberRows(); }
365 
366  /// Get number of nonzero elements
367  virtual int getNumElements() const {
368    int retVal = 0;
369    const CoinPackedMatrix * matrix =modelPtr_->matrix();
370    if ( matrix != NULL ) retVal=matrix->getNumElements();
371    return retVal; }
372
373    /// Return name of row if one exists or Rnnnnnnn
374    /// maxLen is currently ignored and only there to match the signature from the base class!
375    virtual std::string getRowName(int rowIndex,
376                                   unsigned maxLen = std::string::npos) const;
377   
378    /// Return name of column if one exists or Cnnnnnnn
379    /// maxLen is currently ignored and only there to match the signature from the base class!
380    virtual std::string getColName(int colIndex,
381                                   unsigned maxLen = std::string::npos) const;
382   
383 
384  /// Get pointer to array[getNumCols()] of column lower bounds
385  virtual const double * getColLower() const { return modelPtr_->columnLower(); }
386 
387  /// Get pointer to array[getNumCols()] of column upper bounds
388  virtual const double * getColUpper() const { return modelPtr_->columnUpper(); }
389 
390  /** Get pointer to array[getNumRows()] of row constraint senses.
391      <ul>
392      <li>'L' <= constraint
393      <li>'E' =  constraint
394      <li>'G' >= constraint
395      <li>'R' ranged constraint
396      <li>'N' free constraint
397      </ul>
398  */
399  virtual const char * getRowSense() const;
400 
401  /** Get pointer to array[getNumRows()] of rows right-hand sides
402      <ul>
403      <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i]
404      <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i]
405      <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i]
406      <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0
407      </ul>
408  */
409  virtual const double * getRightHandSide() const ;
410 
411  /** Get pointer to array[getNumRows()] of row ranges.
412      <ul>
413      <li> if rowsense()[i] == 'R' then
414      rowrange()[i] == rowupper()[i] - rowlower()[i]
415      <li> if rowsense()[i] != 'R' then
416      rowrange()[i] is undefined
417      </ul>
418  */
419  virtual const double * getRowRange() const ;
420 
421  /// Get pointer to array[getNumRows()] of row lower bounds
422  virtual const double * getRowLower() const { return modelPtr_->rowLower(); }
423 
424  /// Get pointer to array[getNumRows()] of row upper bounds
425  virtual const double * getRowUpper() const { return modelPtr_->rowUpper(); }
426 
427  /// Get pointer to array[getNumCols()] of objective function coefficients
428  virtual const double * getObjCoefficients() const 
429  { return modelPtr_->objective(); }
430 
431  /// Get objective function sense (1 for min (default), -1 for max)
432  virtual double getObjSense() const 
433  { return modelPtr_->optimizationDirection(); }
434 
435  /// Return true if column is continuous
436  virtual bool isContinuous(int colNumber) const;
437  /// Return true if variable is binary
438  virtual bool isBinary(int colIndex) const;
439 
440  /** Return true if column is integer.
441      Note: This function returns true if the the column
442      is binary or a general integer.
443  */
444  virtual bool isInteger(int colIndex) const;
445 
446  /// Return true if variable is general integer
447  virtual bool isIntegerNonBinary(int colIndex) const;
448 
449  /// Return true if variable is binary and not fixed at either bound
450  virtual bool isFreeBinary(int colIndex) const; 
451  /**  Return array of column length
452       0 - continuous
453       1 - binary (may get fixed later)
454       2 - general integer (may get fixed later)
455  */
456  virtual const char * getColType(bool refresh=false) const;
457 
458  /** Return true if column is integer but does not have to
459      be declared as such.
460      Note: This function returns true if the the column
461      is binary or a general integer.
462  */
463  bool isOptionalInteger(int colIndex) const;
464  /** Set the index-th variable to be an optional integer variable */
465  void setOptionalInteger(int index);
466 
467  /// Get pointer to row-wise copy of matrix
468  virtual const CoinPackedMatrix * getMatrixByRow() const;
469 
470  /// Get pointer to column-wise copy of matrix
471  virtual const CoinPackedMatrix * getMatrixByCol() const;
472 
473  /// Get pointer to mutable column-wise copy of matrix
474  virtual CoinPackedMatrix * getMutableMatrixByCol() const;
475 
476    /// Get solver's value for infinity
477  virtual double getInfinity() const { return OsiClpInfinity; }
478  //@}
479 
480  /**@name Methods related to querying the solution */
481  //@{
482  /// Get pointer to array[getNumCols()] of primal solution vector
483  virtual const double * getColSolution() const; 
484 
485  /// Get pointer to array[getNumRows()] of dual prices
486  virtual const double * getRowPrice() const;
487 
488  /// Get a pointer to array[getNumCols()] of reduced costs
489  virtual const double * getReducedCost() const; 
490 
491  /** Get pointer to array[getNumRows()] of row activity levels (constraint
492      matrix times the solution vector */
493  virtual const double * getRowActivity() const; 
494 
495  /// Get objective function value
496  virtual double getObjValue() const;
497 
498  /** Get how many iterations it took to solve the problem (whatever
499      "iteration" mean to the solver. */
500  virtual int getIterationCount() const 
501  { return modelPtr_->numberIterations(); }
502 
503  /** Get as many dual rays as the solver can provide. (In case of proven
504      primal infeasibility there should be at least one.)
505
506      The first getNumRows() ray components will always be associated with
507      the row duals (as returned by getRowPrice()). If \c fullRay is true,
508      the final getNumCols() entries will correspond to the ray components
509      associated with the nonbasic variables. If the full ray is requested
510      and the method cannot provide it, it will throw an exception.
511
512      <strong>NOTE for implementers of solver interfaces:</strong> <br>
513      The double pointers in the vector should point to arrays of length
514      getNumRows() and they should be allocated via new[]. <br>
515     
516      <strong>NOTE for users of solver interfaces:</strong> <br>
517      It is the user's responsibility to free the double pointers in the
518      vector using delete[].
519  */
520  virtual std::vector<double*> getDualRays(int maxNumRays,
521                                           bool fullRay = false) const;
522  /** Get as many primal rays as the solver can provide. (In case of proven
523      dual infeasibility there should be at least one.)
524     
525      <strong>NOTE for implementers of solver interfaces:</strong> <br>
526      The double pointers in the vector should point to arrays of length
527      getNumCols() and they should be allocated via new[]. <br>
528     
529      <strong>NOTE for users of solver interfaces:</strong> <br>
530      It is the user's responsibility to free the double pointers in the
531      vector using delete[].
532  */
533  virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
534 
535  //@}
536  //@}
537 
538  //---------------------------------------------------------------------------
539 
540  /**@name Problem modifying methods */
541  //@{
542  //-------------------------------------------------------------------------
543  /**@name Changing bounds on variables and constraints */
544  //@{
545  /** Set an objective function coefficient */
546  virtual void setObjCoeff( int elementIndex, double elementValue );
547 
548  /** Set a single column lower bound<br>
549      Use -DBL_MAX for -infinity. */
550  virtual void setColLower( int elementIndex, double elementValue );
551 
552  /** Set a single column upper bound<br>
553      Use DBL_MAX for infinity. */
554  virtual void setColUpper( int elementIndex, double elementValue );
555 
556  /** Set a single column lower and upper bound */
557  virtual void setColBounds( int elementIndex,
558                             double lower, double upper );
559 
560  /** Set the bounds on a number of columns simultaneously<br>
561      The default implementation just invokes setColLower() and
562      setColUpper() over and over again.
563      @param indexFirst,indexLast pointers to the beginning and after the
564      end of the array of the indices of the variables whose
565      <em>either</em> bound changes
566      @param boundList the new lower/upper bound pairs for the variables
567  */
568  virtual void setColSetBounds(const int* indexFirst,
569                               const int* indexLast,
570                               const double* boundList);
571 
572  /** Set a single row lower bound<br>
573      Use -DBL_MAX for -infinity. */
574  virtual void setRowLower( int elementIndex, double elementValue );
575 
576  /** Set a single row upper bound<br>
577      Use DBL_MAX for infinity. */
578  virtual void setRowUpper( int elementIndex, double elementValue ) ;
579 
580  /** Set a single row lower and upper bound */
581  virtual void setRowBounds( int elementIndex,
582                             double lower, double upper ) ;
583 
584  /** Set the type of a single row<br> */
585  virtual void setRowType(int index, char sense, double rightHandSide,
586                          double range);
587 
588  /** Set the bounds on a number of rows simultaneously<br>
589      The default implementation just invokes setRowLower() and
590      setRowUpper() over and over again.
591      @param indexFirst,indexLast pointers to the beginning and after the
592      end of the array of the indices of the constraints whose
593      <em>either</em> bound changes
594      @param boundList the new lower/upper bound pairs for the constraints
595  */
596  virtual void setRowSetBounds(const int* indexFirst,
597                               const int* indexLast,
598                               const double* boundList);
599 
600  /** Set the type of a number of rows simultaneously<br>
601      The default implementation just invokes setRowType()
602      over and over again.
603      @param indexFirst,indexLast pointers to the beginning and after the
604      end of the array of the indices of the constraints whose
605      <em>any</em> characteristics changes
606      @param senseList the new senses
607      @param rhsList   the new right hand sides
608      @param rangeList the new ranges
609  */
610  virtual void setRowSetTypes(const int* indexFirst,
611                              const int* indexLast,
612                              const char* senseList,
613                              const double* rhsList,
614                              const double* rangeList);
615    /** Set the objective coefficients for all columns
616        array [getNumCols()] is an array of values for the objective.
617        This defaults to a series of set operations and is here for speed.
618    */
619    virtual void setObjective(const double * array);
620
621    /** Set the lower bounds for all columns
622        array [getNumCols()] is an array of values for the objective.
623        This defaults to a series of set operations and is here for speed.
624    */
625    virtual void setColLower(const double * array);
626
627    /** Set the upper bounds for all columns
628        array [getNumCols()] is an array of values for the objective.
629        This defaults to a series of set operations and is here for speed.
630    */
631    virtual void setColUpper(const double * array);
632
633//    using OsiSolverInterface::setRowName ;
634    /// Set name of row
635//    virtual void setRowName(int rowIndex, std::string & name) ;
636    virtual void setRowName(int rowIndex, std::string  name) ;
637   
638//    using OsiSolverInterface::setColName ;
639    /// Set name of column
640//    virtual void setColName(int colIndex, std::string & name) ;
641    virtual void setColName(int colIndex, std::string  name) ;
642   
643  //@}
644 
645  //-------------------------------------------------------------------------
646  /**@name Integrality related changing methods */
647  //@{
648  /** Set the index-th variable to be a continuous variable */
649  virtual void setContinuous(int index);
650  /** Set the index-th variable to be an integer variable */
651  virtual void setInteger(int index);
652  /** Set the variables listed in indices (which is of length len) to be
653      continuous variables */
654  virtual void setContinuous(const int* indices, int len);
655  /** Set the variables listed in indices (which is of length len) to be
656      integer variables */
657  virtual void setInteger(const int* indices, int len);
658  /// Number of SOS sets
659  inline int numberSOS() const
660  { return numberSOS_;}
661  /// SOS set info
662  inline const CoinSet * setInfo() const
663  { return setInfo_;}
664  /** \brief Identify integer variables and SOS and create corresponding objects.
665 
666    Record integer variables and create an OsiSimpleInteger object for each
667    one.  All existing OsiSimpleInteger objects will be destroyed.
668    If the solver supports SOS then do the same for SOS.
669     If justCount then no objects created and we just store numberIntegers_
670    Returns number of SOS
671  */
672
673  virtual int findIntegersAndSOS(bool justCount);
674  //@}
675 
676  //-------------------------------------------------------------------------
677  /// Set objective function sense (1 for min (default), -1 for max,)
678  virtual void setObjSense(double s ) 
679  { modelPtr_->setOptimizationDirection( s < 0 ? -1 : 1); }
680 
681  /** Set the primal solution column values
682     
683  colsol[numcols()] is an array of values of the problem column
684  variables. These values are copied to memory owned by the
685  solver object or the solver.  They will be returned as the
686  result of colsol() until changed by another call to
687  setColsol() or by a call to any solver routine.  Whether the
688  solver makes use of the solution in any way is
689  solver-dependent.
690  */
691  virtual void setColSolution(const double * colsol);
692 
693  /** Set dual solution vector
694     
695  rowprice[numrows()] is an array of values of the problem row
696  dual variables. These values are copied to memory owned by the
697  solver object or the solver.  They will be returned as the
698  result of rowprice() until changed by another call to
699  setRowprice() or by a call to any solver routine.  Whether the
700  solver makes use of the solution in any way is
701  solver-dependent.
702  */
703  virtual void setRowPrice(const double * rowprice);
704 
705  //-------------------------------------------------------------------------
706  /**@name Methods to expand a problem.<br>
707     Note that if a column is added then by default it will correspond to a
708     continuous variable. */
709  //@{
710
711  //using OsiSolverInterface::addCol ;
712  /** */
713  virtual void addCol(const CoinPackedVectorBase& vec,
714                      const double collb, const double colub,   
715                      const double obj);
716  /*! \brief Add a named column (primal variable) to the problem.
717  */
718  virtual void addCol(const CoinPackedVectorBase& vec,
719                      const double collb, const double colub,   
720                      const double obj, std::string name) ;
721  /** Add a column (primal variable) to the problem. */
722  virtual void addCol(int numberElements, const int * rows, const double * elements,
723                      const double collb, const double colub,   
724                      const double obj) ;
725  /*! \brief Add a named column (primal variable) to the problem.
726   */
727  virtual void addCol(int numberElements,
728                      const int* rows, const double* elements,
729                      const double collb, const double colub,   
730                      const double obj, std::string name) ;
731  /** */
732  virtual void addCols(const int numcols,
733                       const CoinPackedVectorBase * const * cols,
734                       const double* collb, const double* colub,   
735                       const double* obj);
736  /**  */
737  virtual void addCols(const int numcols,
738                       const int * columnStarts, const int * rows, const double * elements,
739                       const double* collb, const double* colub,   
740                       const double* obj);
741  /** */
742  virtual void deleteCols(const int num, const int * colIndices);
743 
744  /** */
745  virtual void addRow(const CoinPackedVectorBase& vec,
746                      const double rowlb, const double rowub);
747  /** */
748    /*! \brief Add a named row (constraint) to the problem.
749   
750      The default implementation adds the row, then changes the name. This
751      can surely be made more efficient within an OsiXXX class.
752    */
753    virtual void addRow(const CoinPackedVectorBase& vec,
754                        const double rowlb, const double rowub,
755                        std::string name) ;
756  virtual void addRow(const CoinPackedVectorBase& vec,
757                      const char rowsen, const double rowrhs,   
758                      const double rowrng);
759  /** Add a row (constraint) to the problem. */
760  virtual void addRow(int numberElements, const int * columns, const double * element,
761                      const double rowlb, const double rowub) ;
762    /*! \brief Add a named row (constraint) to the problem.
763    */
764    virtual void addRow(const CoinPackedVectorBase& vec,
765                        const char rowsen, const double rowrhs,   
766                        const double rowrng, std::string name) ;
767  /** */
768  virtual void addRows(const int numrows,
769                       const CoinPackedVectorBase * const * rows,
770                       const double* rowlb, const double* rowub);
771  /** */
772  virtual void addRows(const int numrows,
773                       const CoinPackedVectorBase * const * rows,
774                       const char* rowsen, const double* rowrhs,   
775                       const double* rowrng);
776
777  /** */
778  virtual void addRows(const int numrows,
779                       const int * rowStarts, const int * columns, const double * element,
780                       const double* rowlb, const double* rowub);
781  ///
782  void modifyCoefficient(int row, int column, double newElement,
783                        bool keepZero=false)
784        {modelPtr_->modifyCoefficient(row,column,newElement, keepZero);}
785
786  /** */
787  virtual void deleteRows(const int num, const int * rowIndices);
788  /**  If solver wants it can save a copy of "base" (continuous) model here
789   */
790  virtual void saveBaseModel() ;
791  /**  Strip off rows to get to this number of rows.
792       If solver wants it can restore a copy of "base" (continuous) model here
793  */
794  virtual void restoreBaseModel(int numberRows);
795 
796  //-----------------------------------------------------------------------
797  /** Apply a collection of row cuts which are all effective.
798      applyCuts seems to do one at a time which seems inefficient.
799  */
800  virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
801  /** Apply a collection of row cuts which are all effective.
802      applyCuts seems to do one at a time which seems inefficient.
803      This uses array of pointers
804  */
805  virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts);
806    /** Apply a collection of cuts.
807
808        Only cuts which have an <code>effectiveness >= effectivenessLb</code>
809        are applied.
810        <ul>
811          <li> ReturnCode.getNumineffective() -- number of cuts which were
812               not applied because they had an
813               <code>effectiveness < effectivenessLb</code>
814          <li> ReturnCode.getNuminconsistent() -- number of invalid cuts
815          <li> ReturnCode.getNuminconsistentWrtIntegerModel() -- number of
816               cuts that are invalid with respect to this integer model
817          <li> ReturnCode.getNuminfeasible() -- number of cuts that would
818               make this integer model infeasible
819          <li> ReturnCode.getNumApplied() -- number of integer cuts which
820               were applied to the integer model
821          <li> cs.size() == getNumineffective() +
822                            getNuminconsistent() +
823                            getNuminconsistentWrtIntegerModel() +
824                            getNuminfeasible() +
825                            getNumApplied()
826        </ul>
827    */
828    virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
829                                          double effectivenessLb = 0.0);
830
831  //@}
832  //@}
833 
834  //---------------------------------------------------------------------------
835 
836public:
837 
838  /**@name Methods to input a problem */
839  //@{
840  /** Load in an problem by copying the arguments (the constraints on the
841      rows are given by lower and upper bounds). If a pointer is NULL then the
842      following values are the default:
843      <ul>
844      <li> <code>colub</code>: all columns have upper bound infinity
845      <li> <code>collb</code>: all columns have lower bound 0
846      <li> <code>rowub</code>: all rows have upper bound infinity
847      <li> <code>rowlb</code>: all rows have lower bound -infinity
848      <li> <code>obj</code>: all variables have 0 objective coefficient
849      </ul>
850  */
851  virtual void loadProblem(const CoinPackedMatrix& matrix,
852                           const double* collb, const double* colub,   
853                           const double* obj,
854                           const double* rowlb, const double* rowub);
855 
856  /** Load in an problem by assuming ownership of the arguments (the
857      constraints on the rows are given by lower and upper bounds). For
858      default values see the previous method.  <br>
859      <strong>WARNING</strong>: The arguments passed to this method will be
860      freed using the C++ <code>delete</code> and <code>delete[]</code>
861      functions.
862  */
863  virtual void assignProblem(CoinPackedMatrix*& matrix,
864                             double*& collb, double*& colub, double*& obj,
865                             double*& rowlb, double*& rowub);
866 
867  /** Load in an problem by copying the arguments (the constraints on the
868      rows are given by sense/rhs/range triplets). If a pointer is NULL then the
869      following values are the default:
870      <ul>
871      <li> <code>colub</code>: all columns have upper bound infinity
872      <li> <code>collb</code>: all columns have lower bound 0
873      <li> <code>obj</code>: all variables have 0 objective coefficient
874      <li> <code>rowsen</code>: all rows are >=
875      <li> <code>rowrhs</code>: all right hand sides are 0
876      <li> <code>rowrng</code>: 0 for the ranged rows
877      </ul>
878  */
879  virtual void loadProblem(const CoinPackedMatrix& matrix,
880                           const double* collb, const double* colub,
881                           const double* obj,
882                           const char* rowsen, const double* rowrhs,   
883                           const double* rowrng);
884 
885  /** Load in an problem by assuming ownership of the arguments (the
886      constraints on the rows are given by sense/rhs/range triplets). For
887      default values see the previous method. <br>
888      <strong>WARNING</strong>: The arguments passed to this method will be
889      freed using the C++ <code>delete</code> and <code>delete[]</code>
890      functions.
891  */
892  virtual void assignProblem(CoinPackedMatrix*& matrix,
893                             double*& collb, double*& colub, double*& obj,
894                             char*& rowsen, double*& rowrhs,
895                             double*& rowrng);
896 
897  /** Just like the other loadProblem() methods except that the matrix is
898      given in a standard column major ordered format (without gaps). */
899  virtual void loadProblem(const int numcols, const int numrows,
900                           const CoinBigIndex * start, const int* index,
901                           const double* value,
902                           const double* collb, const double* colub,   
903                           const double* obj,
904                           const double* rowlb, const double* rowub);
905 
906  /** Just like the other loadProblem() methods except that the matrix is
907      given in a standard column major ordered format (without gaps). */
908  virtual void loadProblem(const int numcols, const int numrows,
909                           const CoinBigIndex * start, const int* index,
910                           const double* value,
911                           const double* collb, const double* colub,   
912                           const double* obj,
913                           const char* rowsen, const double* rowrhs,   
914                           const double* rowrng);
915  /// This loads a model from a coinModel object - returns number of errors
916  virtual int loadFromCoinModel (  CoinModel & modelObject, bool keepSolution=false);
917
918  using OsiSolverInterface::readMps ;
919  /** Read an mps file from the given filename (defaults to Osi reader) - returns
920      number of errors (see OsiMpsReader class) */
921  virtual int readMps(const char *filename,
922                      const char *extension = "mps") ;
923  /** Read an mps file from the given filename returns
924      number of errors (see OsiMpsReader class) */
925  int readMps(const char *filename,bool keepNames,bool allowErrors);
926  /// Read an mps file
927  virtual int readMps (const char *filename, const char*extension,
928                        int & numberSets, CoinSet ** & sets);
929 
930  /** Write the problem into an mps file of the given filename.
931      If objSense is non zero then -1.0 forces the code to write a
932      maximization objective and +1.0 to write a minimization one.
933      If 0.0 then solver can do what it wants */
934  virtual void writeMps(const char *filename,
935                        const char *extension = "mps",
936                        double objSense=0.0) const;
937  /** Write the problem into an mps file of the given filename,
938      names may be null.  formatType is
939      0 - normal
940      1 - extra accuracy
941      2 - IEEE hex (later)
942     
943      Returns non-zero on I/O error
944  */
945  virtual int writeMpsNative(const char *filename, 
946                             const char ** rowNames, const char ** columnNames,
947                             int formatType=0,int numberAcross=2,
948                             double objSense=0.0) const ;
949  /// Read file in LP format (with names)
950  virtual int readLp(const char *filename, const double epsilon = 1e-5);
951  /** Write the problem into an Lp file of the given filename.
952      If objSense is non zero then -1.0 forces the code to write a
953      maximization objective and +1.0 to write a minimization one.
954      If 0.0 then solver can do what it wants.
955      This version calls writeLpNative with names */
956  virtual void writeLp(const char *filename,
957                       const char *extension = "lp",
958                       double epsilon = 1e-5,
959                       int numberAcross = 10,
960                       int decimals = 5,
961                       double objSense = 0.0,
962                       bool useRowNames = true) const;
963  /** Write the problem into the file pointed to by the parameter fp.
964      Other parameters are similar to
965      those of writeLp() with first parameter filename.
966  */
967  virtual void writeLp(FILE *fp,
968               double epsilon = 1e-5,
969               int numberAcross = 10,
970               int decimals = 5,
971               double objSense = 0.0,
972               bool useRowNames = true) const;
973  /**
974     I (JJF) am getting annoyed because I can't just replace a matrix.
975     The default behavior of this is do nothing so only use where that would not matter
976     e.g. strengthening a matrix for MIP
977  */
978  virtual void replaceMatrixOptional(const CoinPackedMatrix & matrix);
979  /// And if it does matter (not used at present)
980  virtual void replaceMatrix(const CoinPackedMatrix & matrix) ;
981  //@}
982 
983  /**@name Message handling (extra for Clp messages).
984     Normally I presume you would want the same language.
985     If not then you could use underlying model pointer */
986  //@{
987  /** Pass in a message handler
988     
989      It is the client's responsibility to destroy a message handler installed
990      by this routine; it will not be destroyed when the solver interface is
991      destroyed.
992  */
993  virtual void passInMessageHandler(CoinMessageHandler * handler);
994  /// Set language
995  void newLanguage(CoinMessages::Language language);
996  void setLanguage(CoinMessages::Language language)
997  {newLanguage(language);}
998  /// Set log level (will also set underlying solver's log level)
999  void setLogLevel(int value);
1000  /// Create C++ lines to get to current state
1001  void generateCpp( FILE * fp);
1002  //@}
1003  //---------------------------------------------------------------------------
1004 
1005  /**@name Clp specific public interfaces */
1006  //@{
1007  /// Get pointer to Clp model
1008  ClpSimplex * getModelPtr() const ;
1009  /// Set pointer to Clp model and return old
1010  inline ClpSimplex * swapModelPtr(ClpSimplex * newModel)
1011  { ClpSimplex * model = modelPtr_; modelPtr_=newModel;return model;}
1012  /// Get special options
1013  inline unsigned int specialOptions() const
1014  { return specialOptions_;}
1015  void setSpecialOptions(unsigned int value);
1016  /// Last algorithm used , 1 = primal, 2 = dual
1017  inline int lastAlgorithm() const
1018  { return lastAlgorithm_;}
1019  /// Get scaling action option
1020  inline int cleanupScaling() const
1021  { return cleanupScaling_;}
1022  /** Set Scaling option
1023      When scaling is on it is possible that the scaled problem
1024      is feasible but the unscaled is not.  Clp returns a secondary
1025      status code to that effect.  This option allows for a cleanup.
1026      If you use it I would suggest 1.
1027      This only affects actions when scaled optimal
1028      0 - no action
1029      1 - clean up using dual if primal infeasibility
1030      2 - clean up using dual if dual infeasibility
1031      3 - clean up using dual if primal or dual infeasibility
1032      11,12,13 - as 1,2,3 but use primal
1033  */
1034  inline void setCleanupScaling(int value)
1035  { cleanupScaling_=value;}
1036  /** Get smallest allowed element in cut.
1037      If smaller than this then ignored */
1038  inline double smallestElementInCut() const
1039  { return smallestElementInCut_;}
1040  /** Set smallest allowed element in cut.
1041      If smaller than this then ignored */
1042  inline void setSmallestElementInCut(double value)
1043  { smallestElementInCut_=value;}
1044  /** Get smallest change in cut.
1045      If (upper-lower)*element < this then element is
1046      taken out and cut relaxed.
1047      (upper-lower) is taken to be at least 1.0 and
1048      this is assumed >= smallestElementInCut_
1049  */
1050  inline double smallestChangeInCut() const
1051  { return smallestChangeInCut_;}
1052  /** Set smallest change in cut.
1053      If (upper-lower)*element < this then element is
1054      taken out and cut relaxed.
1055      (upper-lower) is taken to be at least 1.0 and
1056      this is assumed >= smallestElementInCut_
1057  */
1058  inline void setSmallestChangeInCut(double value)
1059  { smallestChangeInCut_=value;}
1060  /// Pass in initial solve options
1061  inline void setSolveOptions(const ClpSolve & options)
1062  { solveOptions_ = options;}
1063  /** Tighten bounds - lightweight or very lightweight
1064      0 - normal, 1 lightweight but just integers, 2 lightweight and all
1065  */
1066  virtual int tightenBounds(int lightweight=0);
1067  /// Return number of entries in L part of current factorization
1068  virtual CoinBigIndex getSizeL() const;
1069  /// Return number of entries in U part of current factorization
1070  virtual CoinBigIndex getSizeU() const;
1071  /// Get disaster handler
1072  const OsiClpDisasterHandler * disasterHandler() const
1073  { return disasterHandler_;}
1074  /// Pass in disaster handler
1075  void passInDisasterHandler(OsiClpDisasterHandler * handler);
1076  /// Get fake objective
1077  ClpLinearObjective * fakeObjective() const
1078  { return fakeObjective_;}
1079  /// Set fake objective (and take ownership)
1080  void setFakeObjective(ClpLinearObjective * fakeObjective);
1081  /// Set fake objective
1082  void setFakeObjective(double * fakeObjective);
1083  //@}
1084 
1085  //---------------------------------------------------------------------------
1086 
1087  /**@name Constructors and destructors */
1088  //@{
1089  /// Default Constructor
1090  OsiClpSolverInterface ();
1091 
1092  /// Clone
1093  virtual OsiSolverInterface * clone(bool copyData = true) const;
1094 
1095  /// Copy constructor
1096  OsiClpSolverInterface (const OsiClpSolverInterface &);
1097 
1098  /// Borrow constructor - only delete one copy
1099  OsiClpSolverInterface (ClpSimplex * rhs, bool reallyOwn=false);
1100 
1101  /// Releases so won't error
1102  void releaseClp();
1103 
1104  /// Assignment operator
1105  OsiClpSolverInterface & operator=(const OsiClpSolverInterface& rhs);
1106 
1107  /// Destructor
1108  virtual ~OsiClpSolverInterface ();
1109 
1110  /// Resets as if default constructor
1111  virtual void reset();
1112  //@}
1113 
1114  //---------------------------------------------------------------------------
1115 
1116protected:
1117  ///@name Protected methods
1118  //@{
1119  /** Apply a row cut (append to constraint matrix). */
1120  virtual void applyRowCut(const OsiRowCut& rc);
1121 
1122  /** Apply a column cut (adjust one or more bounds). */
1123  virtual void applyColCut(const OsiColCut& cc);
1124  //@}
1125 
1126  //---------------------------------------------------------------------------
1127 
1128protected:
1129  /**@name Protected methods */
1130  //@{
1131  /// The real work of a copy constructor (used by copy and assignment)
1132  void gutsOfDestructor();
1133 
1134  /// Deletes all mutable stuff
1135  void freeCachedResults() const;
1136 
1137  /// Deletes all mutable stuff for row ranges etc
1138  void freeCachedResults0() const;
1139 
1140  /// Deletes all mutable stuff for matrix etc
1141  void freeCachedResults1() const;
1142 
1143  /// A method that fills up the rowsense_, rhs_ and rowrange_ arrays
1144  void extractSenseRhsRange() const;
1145 
1146  ///
1147  void fillParamMaps();
1148  /** Warm start
1149     
1150  NOTE  artificials are treated as +1 elements so for <= rhs
1151  artificial will be at lower bound if constraint is tight
1152 
1153  This means that Clpsimplex flips artificials as it works
1154  in terms of row activities
1155  */
1156  CoinWarmStartBasis getBasis(ClpSimplex * model) const;
1157  /** Sets up working basis as a copy of input
1158     
1159  NOTE  artificials are treated as +1 elements so for <= rhs
1160  artificial will be at lower bound if constraint is tight
1161 
1162  This means that Clpsimplex flips artificials as it works
1163  in terms of row activities
1164  */
1165  void setBasis( const CoinWarmStartBasis & basis, ClpSimplex * model);
1166  /// Crunch down problem a bit
1167  void crunch();
1168  /// Extend scale factors
1169  void redoScaleFactors(int numberRows,const CoinBigIndex * starts,
1170                        const int * indices, const double * elements);
1171public:
1172  /** Sets up working basis as a copy of input and puts in as basis
1173  */
1174  void setBasis( const CoinWarmStartBasis & basis);
1175  /// Just puts current basis_ into ClpSimplex model
1176  inline void setBasis( )
1177  { setBasis(basis_,modelPtr_);}
1178  /// Warm start difference from basis_ to statusArray
1179  CoinWarmStartDiff * getBasisDiff(const unsigned char * statusArray) const ;
1180  /// Warm start from statusArray
1181  CoinWarmStartBasis * getBasis(const unsigned char * statusArray) const ;
1182  /// Delete all scale factor stuff and reset option
1183  void deleteScaleFactors();
1184  /// If doing fast hot start then ranges are computed
1185  inline const double * upRange() const
1186  { return rowActivity_;}
1187  inline const double * downRange() const
1188  { return columnActivity_;}
1189  /// Pass in range array
1190  inline void passInRanges(int * array)
1191  { whichRange_=array;}
1192  /// Pass in sos stuff from AMPl
1193  void setSOSData(int numberSOS,const char * type,
1194                  const int * start,const int * indices, const double * weights=NULL);
1195  /// Compute largest amount any at continuous away from bound
1196  void computeLargestAway();
1197  /// Get largest amount continuous away from bound
1198  inline double largestAway() const
1199  { return largestAway_;}
1200  /// Set largest amount continuous away from bound
1201  inline void setLargestAway(double value)
1202  { largestAway_ = value;}
1203  /// Sort of lexicographic resolve
1204  void lexSolve();
1205protected:
1206  //@}
1207 
1208  /**@name Protected member data */
1209  //@{
1210  /// Clp model represented by this class instance
1211  mutable ClpSimplex * modelPtr_;
1212  /// Linear objective - just points to ClpModel
1213  double * linearObjective_;
1214  /**@name Cached information derived from the OSL model */
1215  //@{
1216  /// Pointer to dense vector of row sense indicators
1217  mutable char    *rowsense_;
1218 
1219  /// Pointer to dense vector of row right-hand side values
1220  mutable double  *rhs_;
1221 
1222  /** Pointer to dense vector of slack upper bounds for range
1223      constraints (undefined for non-range rows)
1224  */
1225  mutable double  *rowrange_;
1226 
1227  /** A pointer to the warmstart information to be used in the hotstarts.
1228      This is NOT efficient and more thought should be given to it... */
1229  mutable CoinWarmStartBasis* ws_;
1230  /** also save row and column information for hot starts
1231      only used in hotstarts so can be casual */
1232  mutable double * rowActivity_;
1233  mutable double * columnActivity_;
1234  /// Stuff for fast dual
1235  ClpNodeStuff stuff_;
1236  /// Number of SOS sets
1237  int numberSOS_;
1238  /// SOS set info
1239  CoinSet * setInfo_;
1240  /// Alternate model (hot starts) - but also could be permanent and used for crunch
1241  ClpSimplex * smallModel_;
1242  /// factorization for hot starts
1243  ClpFactorization * factorization_;
1244  /** Smallest allowed element in cut.
1245      If smaller than this then ignored */
1246  double smallestElementInCut_;
1247  /** Smallest change in cut.
1248      If (upper-lower)*element < this then element is
1249      taken out and cut relaxed. */
1250  double smallestChangeInCut_;
1251  /// Largest amount continuous away from bound
1252  double largestAway_;
1253  /// Arrays for hot starts
1254  char * spareArrays_;
1255  /** Warmstart information to be used in resolves. */
1256  CoinWarmStartBasis basis_;
1257  /** The original iteration limit before hotstarts started. */
1258  int itlimOrig_;
1259 
1260  /// Last algorithm used , 1 = primal, 2 = dual
1261  mutable int lastAlgorithm_;
1262 
1263  /// To say if destructor should delete underlying model
1264  bool notOwned_;
1265 
1266  /// Pointer to row-wise copy of problem matrix coefficients.
1267  mutable CoinPackedMatrix *matrixByRow_; 
1268 
1269  /// Pointer to row-wise copy of continuous problem matrix coefficients.
1270  CoinPackedMatrix *matrixByRowAtContinuous_; 
1271 
1272  /// Pointer to integer information
1273  char * integerInformation_;
1274 
1275  /** Pointer to variables for which we want range information
1276      The number is in [0]
1277      memory is not owned by OsiClp
1278  */
1279  int * whichRange_;
1280
1281  //std::map<OsiIntParam, ClpIntParam> intParamMap_;
1282  //std::map<OsiDblParam, ClpDblParam> dblParamMap_;
1283  //std::map<OsiStrParam, ClpStrParam> strParamMap_;
1284 
1285  /// To save data in OsiSimplex stuff
1286  mutable ClpDataSave saveData_;
1287  /// Options for initialSolve
1288  ClpSolve solveOptions_;
1289  /** Scaling option
1290      When scaling is on it is possible that the scaled problem
1291      is feasible but the unscaled is not.  Clp returns a secondary
1292      status code to that effect.  This option allows for a cleanup.
1293      If you use it I would suggest 1.
1294      This only affects actions when scaled optimal
1295      0 - no action
1296      1 - clean up using dual if primal infeasibility
1297      2 - clean up using dual if dual infeasibility
1298      3 - clean up using dual if primal or dual infeasibility
1299      11,12,13 - as 1,2,3 but use primal
1300  */
1301  int cleanupScaling_;
1302  /** Special options
1303      0x80000000 off
1304      0 simple stuff for branch and bound
1305      1 try and keep work regions as much as possible
1306      2 do not use any perturbation
1307      4 allow exit before re-factorization
1308      8 try and re-use factorization if no cuts
1309      16 use standard strong branching rather than clp's
1310      32 Just go to first factorization in fast dual
1311      64 try and tighten bounds in crunch
1312      128 Model will only change in column bounds
1313      256 Clean up model before hot start
1314      512 Give user direct access to Clp regions in getBInvARow etc
1315      1024 Don't "borrow" model in initialSolve
1316      2048 Don't crunch
1317      4096 quick check for optimality
1318      Bits above 8192 give where called from in Cbc
1319      At present 0 is normal, 1 doing fast hotstarts, 2 is can do quick check
1320      65536 Keep simple i.e. no  crunch etc
1321      131072 Try and keep scaling factors around
1322      262144 Don't try and tighten bounds (funny global cuts)
1323      524288 Fake objective and 0-1
1324      1048576 Don't recompute ray after crunch
1325  */
1326  mutable unsigned int specialOptions_;
1327  /// Copy of model when option 131072 set
1328  ClpSimplex * baseModel_;
1329  /// Number of rows when last "scaled"
1330  int lastNumberRows_;
1331  /// Continuous model
1332  ClpSimplex * continuousModel_;
1333  /// Possible disaster handler
1334  OsiClpDisasterHandler * disasterHandler_ ;
1335  /// Fake objective
1336  ClpLinearObjective * fakeObjective_;
1337  /// Row scale factors (has inverse at end)
1338  CoinDoubleArrayWithLength rowScale_; 
1339  /// Column scale factors (has inverse at end)
1340  CoinDoubleArrayWithLength columnScale_; 
1341  //@}
1342};
1343 
1344class OsiClpDisasterHandler : public ClpDisasterHandler {
1345public:
1346  /**@name Virtual methods that the derived classe should provide.
1347  */
1348  //@{
1349  /// Into simplex
1350  virtual void intoSimplex();
1351  /// Checks if disaster
1352  virtual bool check() const ;
1353  /// saves information for next attempt
1354  virtual void saveInfo();
1355  /// Type of disaster 0 can fix, 1 abort
1356  virtual int typeOfDisaster();
1357  //@}
1358 
1359 
1360  /**@name Constructors, destructor */
1361
1362  //@{
1363  /** Default constructor. */
1364  OsiClpDisasterHandler(OsiClpSolverInterface * model = NULL);
1365  /** Destructor */
1366  virtual ~OsiClpDisasterHandler();
1367  // Copy
1368  OsiClpDisasterHandler(const OsiClpDisasterHandler&);
1369  // Assignment
1370  OsiClpDisasterHandler& operator=(const OsiClpDisasterHandler&);
1371  /// Clone
1372  virtual ClpDisasterHandler * clone() const;
1373
1374  //@}
1375 
1376  /**@name Sets/gets */
1377
1378  //@{
1379  /** set model. */
1380  void setOsiModel(OsiClpSolverInterface * model);
1381  /// Get model
1382  inline OsiClpSolverInterface * osiModel() const
1383  { return osiModel_;}
1384  /// Set where from
1385  inline void setWhereFrom(int value)
1386  { whereFrom_=value;}
1387  /// Get where from
1388  inline int whereFrom() const
1389  { return whereFrom_;}
1390  /// Set phase
1391  inline void setPhase(int value)
1392  { phase_=value;}
1393  /// Get phase
1394  inline int phase() const
1395  { return phase_;}
1396  /// are we in trouble
1397  inline bool inTrouble() const
1398  { return inTrouble_;}
1399 
1400  //@}
1401 
1402 
1403protected:
1404  /**@name Data members
1405     The data members are protected to allow access for derived classes. */
1406  //@{
1407  /// Pointer to model
1408  OsiClpSolverInterface * osiModel_;
1409  /** Where from
1410      0 dual (resolve)
1411      1 crunch
1412      2 primal (resolve)
1413      4 dual (initialSolve)
1414      6 primal (initialSolve)
1415  */
1416  int whereFrom_;
1417  /** phase
1418      0 initial
1419      1 trying continuing with back in and maybe different perturb
1420      2 trying continuing with back in and different scaling
1421      3 trying dual from all slack
1422      4 trying primal from previous stored basis
1423  */
1424  int phase_;
1425  /// Are we in trouble
1426  bool inTrouble_;
1427     
1428  //@}
1429};
1430// So unit test can find out if NDEBUG set
1431bool OsiClpHasNDEBUG();
1432//#############################################################################
1433/** A function that tests the methods in the OsiClpSolverInterface class. The
1434    only reason for it not to be a member method is that this way it doesn't
1435    have to be compiled into the library. And that's a gain, because the
1436    library should be compiled with optimization on, but this method should be
1437    compiled with debugging. Also, if this method is compiled with
1438    optimization, the compilation takes 10-15 minutes and the machine pages
1439    (has 256M core memory!)... */
1440int
1441OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
1442#endif
Note: See TracBrowser for help on using the repository browser.