source: trunk/Clp/src/ClpModel.hpp @ 2030

Last change on this file since 2030 was 1972, checked in by forrest, 6 years ago

changes to allow more options and stop on feasible (and a few other things)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 48.8 KB
Line 
1/* $Id: ClpModel.hpp 1972 2013-07-21 09:00:37Z forrest $ */
2// Copyright (C) 2002, International Business Machines
3// Corporation and others.  All Rights Reserved.
4// This code is licensed under the terms of the Eclipse Public License (EPL).
5
6#ifndef ClpModel_H
7#define ClpModel_H
8
9#include "ClpConfig.h"
10
11#include <iostream>
12#include <cassert>
13#include <cmath>
14#include <vector>
15#include <string>
16//#ifndef COIN_USE_CLP
17//#define COIN_USE_CLP
18//#endif
19#include "ClpPackedMatrix.hpp"
20#include "CoinMessageHandler.hpp"
21#include "CoinHelperFunctions.hpp"
22#include "CoinTypes.hpp"
23#include "CoinFinite.hpp"
24#include "ClpParameters.hpp"
25#include "ClpObjective.hpp"
26class ClpEventHandler;
27/** This is the base class for Linear and quadratic Models
28    This knows nothing about the algorithm, but it seems to
29    have a reasonable amount of information
30
31    I would welcome suggestions for what should be in this and
32    how it relates to OsiSolverInterface.  Some methods look
33    very similar.
34
35*/
36class CoinBuild;
37class CoinModel;
38class ClpModel {
39
40public:
41
42     /**@name Constructors and destructor
43        Note - copy methods copy ALL data so can chew up memory
44        until other copy is freed
45      */
46     //@{
47     /// Default constructor
48     ClpModel (bool emptyMessages = false  );
49
50     /** Copy constructor. May scale depending on mode
51         -1 leave mode as is
52         0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 auto-but-as-initialSolve-in-bab
53     */
54     ClpModel(const ClpModel & rhs, int scalingMode = -1);
55     /// Assignment operator. This copies the data
56     ClpModel & operator=(const ClpModel & rhs);
57     /** Subproblem constructor.  A subset of whole model is created from the
58         row and column lists given.  The new order is given by list order and
59         duplicates are allowed.  Name and integer information can be dropped
60     */
61     ClpModel (const ClpModel * wholeModel,
62               int numberRows, const int * whichRows,
63               int numberColumns, const int * whichColumns,
64               bool dropNames = true, bool dropIntegers = true);
65     /// Destructor
66     ~ClpModel (  );
67     //@}
68
69     /**@name Load model - loads some stuff and initializes others */
70     //@{
71     /** Loads a problem (the constraints on the
72         rows are given by lower and upper bounds). If a pointer is 0 then the
73         following values are the default:
74         <ul>
75           <li> <code>colub</code>: all columns have upper bound infinity
76           <li> <code>collb</code>: all columns have lower bound 0
77           <li> <code>rowub</code>: all rows have upper bound infinity
78           <li> <code>rowlb</code>: all rows have lower bound -infinity
79       <li> <code>obj</code>: all variables have 0 objective coefficient
80         </ul>
81     */
82     void loadProblem (  const ClpMatrixBase& matrix,
83                         const double* collb, const double* colub,
84                         const double* obj,
85                         const double* rowlb, const double* rowub,
86                         const double * rowObjective = NULL);
87     void loadProblem (  const CoinPackedMatrix& matrix,
88                         const double* collb, const double* colub,
89                         const double* obj,
90                         const double* rowlb, const double* rowub,
91                         const double * rowObjective = NULL);
92
93     /** Just like the other loadProblem() method except that the matrix is
94       given in a standard column major ordered format (without gaps). */
95     void loadProblem (  const int numcols, const int numrows,
96                         const CoinBigIndex* start, const int* index,
97                         const double* value,
98                         const double* collb, const double* colub,
99                         const double* obj,
100                         const double* rowlb, const double* rowub,
101                         const double * rowObjective = NULL);
102     /** This loads a model from a coinModel object - returns number of errors.
103
104         modelObject not const as may be changed as part of process
105         If tryPlusMinusOne then will try adding as +-1 matrix
106     */
107     int loadProblem (  CoinModel & modelObject, bool tryPlusMinusOne = false);
108     /// This one is for after presolve to save memory
109     void loadProblem (  const int numcols, const int numrows,
110                         const CoinBigIndex* start, const int* index,
111                         const double* value, const int * length,
112                         const double* collb, const double* colub,
113                         const double* obj,
114                         const double* rowlb, const double* rowub,
115                         const double * rowObjective = NULL);
116     /** Load up quadratic objective.  This is stored as a CoinPackedMatrix */
117     void loadQuadraticObjective(const int numberColumns,
118                                 const CoinBigIndex * start,
119                                 const int * column, const double * element);
120     void loadQuadraticObjective (  const CoinPackedMatrix& matrix);
121     /// Get rid of quadratic objective
122     void deleteQuadraticObjective();
123     /// This just loads up a row objective
124     void setRowObjective(const double * rowObjective);
125     /// Read an mps file from the given filename
126     int readMps(const char *filename,
127                 bool keepNames = false,
128                 bool ignoreErrors = false);
129     /// Read GMPL files from the given filenames
130     int readGMPL(const char *filename, const char * dataName,
131                  bool keepNames = false);
132     /// Copy in integer informations
133     void copyInIntegerInformation(const char * information);
134     /// Drop integer informations
135     void deleteIntegerInformation();
136     /** Set the index-th variable to be a continuous variable */
137     void setContinuous(int index);
138     /** Set the index-th variable to be an integer variable */
139     void setInteger(int index);
140     /** Return true if the index-th variable is an integer variable */
141     bool isInteger(int index) const;
142     /// Resizes rim part of model
143     void resize (int newNumberRows, int newNumberColumns);
144     /// Deletes rows
145     void deleteRows(int number, const int * which);
146     /// Add one row
147     void addRow(int numberInRow, const int * columns,
148                 const double * elements, double rowLower = -COIN_DBL_MAX,
149                 double rowUpper = COIN_DBL_MAX);
150     /// Add rows
151     void addRows(int number, const double * rowLower,
152                  const double * rowUpper,
153                  const CoinBigIndex * rowStarts, const int * columns,
154                  const double * elements);
155     /// Add rows
156     void addRows(int number, const double * rowLower,
157                  const double * rowUpper,
158                  const CoinBigIndex * rowStarts, const int * rowLengths,
159                  const int * columns,
160                  const double * elements);
161#ifndef CLP_NO_VECTOR
162     void addRows(int number, const double * rowLower,
163                  const double * rowUpper,
164                  const CoinPackedVectorBase * const * rows);
165#endif
166     /** Add rows from a build object.
167         If tryPlusMinusOne then will try adding as +-1 matrix
168         if no matrix exists.
169         Returns number of errors e.g. duplicates
170     */
171     int addRows(const CoinBuild & buildObject, bool tryPlusMinusOne = false,
172                 bool checkDuplicates = true);
173     /** Add rows from a model object.  returns
174         -1 if object in bad state (i.e. has column information)
175         otherwise number of errors.
176
177         modelObject non const as can be regularized as part of build
178         If tryPlusMinusOne then will try adding as +-1 matrix
179         if no matrix exists.
180     */
181     int addRows(CoinModel & modelObject, bool tryPlusMinusOne = false,
182                 bool checkDuplicates = true);
183
184     /// Deletes columns
185     void deleteColumns(int number, const int * which);
186     /// Deletes rows AND columns (keeps old sizes)
187     void deleteRowsAndColumns(int numberRows, const int * whichRows,
188                               int numberColumns, const int * whichColumns);
189     /// Add one column
190     void addColumn(int numberInColumn,
191                    const int * rows,
192                    const double * elements,
193                    double columnLower = 0.0,
194                    double  columnUpper = COIN_DBL_MAX,
195                    double  objective = 0.0);
196     /// Add columns
197     void addColumns(int number, const double * columnLower,
198                     const double * columnUpper,
199                     const double * objective,
200                     const CoinBigIndex * columnStarts, const int * rows,
201                     const double * elements);
202     void addColumns(int number, const double * columnLower,
203                     const double * columnUpper,
204                     const double * objective,
205                     const CoinBigIndex * columnStarts, const int * columnLengths,
206                     const int * rows,
207                     const double * elements);
208#ifndef CLP_NO_VECTOR
209     void addColumns(int number, const double * columnLower,
210                     const double * columnUpper,
211                     const double * objective,
212                     const CoinPackedVectorBase * const * columns);
213#endif
214     /** Add columns from a build object
215         If tryPlusMinusOne then will try adding as +-1 matrix
216         if no matrix exists.
217         Returns number of errors e.g. duplicates
218     */
219     int addColumns(const CoinBuild & buildObject, bool tryPlusMinusOne = false,
220                    bool checkDuplicates = true);
221     /** Add columns from a model object.  returns
222         -1 if object in bad state (i.e. has row information)
223         otherwise number of errors
224         modelObject non const as can be regularized as part of build
225         If tryPlusMinusOne then will try adding as +-1 matrix
226         if no matrix exists.
227     */
228     int addColumns(CoinModel & modelObject, bool tryPlusMinusOne = false,
229                    bool checkDuplicates = true);
230     /// Modify one element of a matrix
231     inline void modifyCoefficient(int row, int column, double newElement,
232                                   bool keepZero = false) {
233          matrix_->modifyCoefficient(row, column, newElement, keepZero);
234     }
235     /** Change row lower bounds */
236     void chgRowLower(const double * rowLower);
237     /** Change row upper bounds */
238     void chgRowUpper(const double * rowUpper);
239     /** Change column lower bounds */
240     void chgColumnLower(const double * columnLower);
241     /** Change column upper bounds */
242     void chgColumnUpper(const double * columnUpper);
243     /** Change objective coefficients */
244     void chgObjCoefficients(const double * objIn);
245     /** Borrow model.  This is so we don't have to copy large amounts
246         of data around.  It assumes a derived class wants to overwrite
247         an empty model with a real one - while it does an algorithm */
248     void borrowModel(ClpModel & otherModel);
249     /** Return model - nulls all arrays so can be deleted safely
250         also updates any scalars */
251     void returnModel(ClpModel & otherModel);
252
253     /// Create empty ClpPackedMatrix
254     void createEmptyMatrix();
255     /** Really clean up matrix (if ClpPackedMatrix).
256         a) eliminate all duplicate AND small elements in matrix
257         b) remove all gaps and set extraGap_ and extraMajor_ to 0.0
258         c) reallocate arrays and make max lengths equal to lengths
259         d) orders elements
260         returns number of elements eliminated or -1 if not ClpPackedMatrix
261     */
262     int cleanMatrix(double threshold = 1.0e-20);
263     /// Copy contents - resizing if necessary - otherwise re-use memory
264     void copy(const ClpMatrixBase * from, ClpMatrixBase * & to);
265#ifndef CLP_NO_STD
266     /// Drops names - makes lengthnames 0 and names empty
267     void dropNames();
268     /// Copies in names
269     void copyNames(const std::vector<std::string> & rowNames,
270                    const std::vector<std::string> & columnNames);
271     /// Copies in Row names - modifies names first .. last-1
272     void copyRowNames(const std::vector<std::string> & rowNames, int first, int last);
273     /// Copies in Column names - modifies names first .. last-1
274     void copyColumnNames(const std::vector<std::string> & columnNames, int first, int last);
275     /// Copies in Row names - modifies names first .. last-1
276     void copyRowNames(const char * const * rowNames, int first, int last);
277     /// Copies in Column names - modifies names first .. last-1
278     void copyColumnNames(const char * const * columnNames, int first, int last);
279     /// Set name of row
280     void setRowName(int rowIndex, std::string & name) ;
281     /// Set name of col
282     void setColumnName(int colIndex, std::string & name) ;
283#endif
284     /** Find a network subset.
285         rotate array should be numberRows.  On output
286         -1 not in network
287          0 in network as is
288          1 in network with signs swapped
289         Returns number of network rows
290     */
291     int findNetwork(char * rotate, double fractionNeeded = 0.75);
292     /** This creates a coinModel object
293     */
294     CoinModel * createCoinModel() const;
295
296     /** Write the problem in MPS format to the specified file.
297
298     Row and column names may be null.
299     formatType is
300     <ul>
301       <li> 0 - normal
302       <li> 1 - extra accuracy
303       <li> 2 - IEEE hex
304     </ul>
305
306     Returns non-zero on I/O error
307     */
308     int writeMps(const char *filename,
309                  int formatType = 0, int numberAcross = 2,
310                  double objSense = 0.0) const ;
311     //@}
312     /**@name gets and sets */
313     //@{
314     /// Number of rows
315     inline int numberRows() const {
316          return numberRows_;
317     }
318     inline int getNumRows() const {
319          return numberRows_;
320     }
321     /// Number of columns
322     inline int getNumCols() const {
323          return numberColumns_;
324     }
325     inline int numberColumns() const {
326          return numberColumns_;
327     }
328     /// Primal tolerance to use
329     inline double primalTolerance() const {
330          return dblParam_[ClpPrimalTolerance];
331     }
332     void setPrimalTolerance( double value) ;
333     /// Dual tolerance to use
334     inline double dualTolerance() const  {
335          return dblParam_[ClpDualTolerance];
336     }
337     void setDualTolerance( double value) ;
338     /// Primal objective limit
339     inline double primalObjectiveLimit() const {
340          return dblParam_[ClpPrimalObjectiveLimit];
341     }
342     void setPrimalObjectiveLimit(double value);
343     /// Dual objective limit
344     inline double dualObjectiveLimit() const {
345          return dblParam_[ClpDualObjectiveLimit];
346     }
347     void setDualObjectiveLimit(double value);
348     /// Objective offset
349     inline double objectiveOffset() const {
350          return dblParam_[ClpObjOffset];
351     }
352     void setObjectiveOffset(double value);
353     /// Presolve tolerance to use
354     inline double presolveTolerance() const {
355          return dblParam_[ClpPresolveTolerance];
356     }
357#ifndef CLP_NO_STD
358     inline const std::string & problemName() const {
359          return strParam_[ClpProbName];
360     }
361#endif
362     /// Number of iterations
363     inline int numberIterations() const  {
364          return numberIterations_;
365     }
366     inline int getIterationCount() const {
367          return numberIterations_;
368     }
369     inline void setNumberIterations(int numberIterationsNew) {
370          numberIterations_ = numberIterationsNew;
371     }
372     /** Solve type - 1 simplex, 2 simplex interface, 3 Interior.*/
373     inline int solveType() const {
374          return solveType_;
375     }
376     inline void setSolveType(int type) {
377          solveType_ = type;
378     }
379     /// Maximum number of iterations
380     inline int maximumIterations() const {
381          return intParam_[ClpMaxNumIteration];
382     }
383     void setMaximumIterations(int value);
384     /// Maximum time in seconds (from when set called)
385     inline double maximumSeconds() const {
386          return dblParam_[ClpMaxSeconds];
387     }
388     void setMaximumSeconds(double value);
389     /// Returns true if hit maximum iterations (or time)
390     bool hitMaximumIterations() const;
391     /** Status of problem:
392         -1 - unknown e.g. before solve or if postSolve says not optimal
393         0 - optimal
394         1 - primal infeasible
395         2 - dual infeasible
396         3 - stopped on iterations or time
397         4 - stopped due to errors
398         5 - stopped by event handler (virtual int ClpEventHandler::event())
399     */
400     inline int status() const            {
401          return problemStatus_;
402     }
403     inline int problemStatus() const            {
404          return problemStatus_;
405     }
406     /// Set problem status
407     inline void setProblemStatus(int problemStatusNew) {
408          problemStatus_ = problemStatusNew;
409     }
410     /** Secondary status of problem - may get extended
411         0 - none
412         1 - primal infeasible because dual limit reached OR (probably primal
413         infeasible but can't prove it  - main status was 4)
414         2 - scaled problem optimal - unscaled problem has primal infeasibilities
415         3 - scaled problem optimal - unscaled problem has dual infeasibilities
416         4 - scaled problem optimal - unscaled problem has primal and dual infeasibilities
417         5 - giving up in primal with flagged variables
418         6 - failed due to empty problem check
419         7 - postSolve says not optimal
420         8 - failed due to bad element check
421         9 - status was 3 and stopped on time
422         10 - status was 3 but stopped as primal feasible
423         100 up - translation of enum from ClpEventHandler
424     */
425     inline int secondaryStatus() const            {
426          return secondaryStatus_;
427     }
428     inline void setSecondaryStatus(int newstatus) {
429          secondaryStatus_ = newstatus;
430     }
431     /// Are there a numerical difficulties?
432     inline bool isAbandoned() const             {
433          return problemStatus_ == 4;
434     }
435     /// Is optimality proven?
436     inline bool isProvenOptimal() const         {
437          return problemStatus_ == 0;
438     }
439     /// Is primal infeasiblity proven?
440     inline bool isProvenPrimalInfeasible() const {
441          return problemStatus_ == 1;
442     }
443     /// Is dual infeasiblity proven?
444     inline bool isProvenDualInfeasible() const  {
445          return problemStatus_ == 2;
446     }
447     /// Is the given primal objective limit reached?
448     bool isPrimalObjectiveLimitReached() const ;
449     /// Is the given dual objective limit reached?
450     bool isDualObjectiveLimitReached() const ;
451     /// Iteration limit reached?
452     inline bool isIterationLimitReached() const {
453          return problemStatus_ == 3;
454     }
455     /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
456     inline double optimizationDirection() const {
457          return  optimizationDirection_;
458     }
459     inline double getObjSense() const    {
460          return optimizationDirection_;
461     }
462     void setOptimizationDirection(double value);
463     /// Primal row solution
464     inline double * primalRowSolution() const    {
465          return rowActivity_;
466     }
467     inline const double * getRowActivity() const {
468          return rowActivity_;
469     }
470     /// Primal column solution
471     inline double * primalColumnSolution() const {
472          return columnActivity_;
473     }
474     inline const double * getColSolution() const {
475          return columnActivity_;
476     }
477     inline void setColSolution(const double * input) {
478          memcpy(columnActivity_, input, numberColumns_ * sizeof(double));
479     }
480     /// Dual row solution
481     inline double * dualRowSolution() const      {
482          return dual_;
483     }
484     inline const double * getRowPrice() const    {
485          return dual_;
486     }
487     /// Reduced costs
488     inline double * dualColumnSolution() const   {
489          return reducedCost_;
490     }
491     inline const double * getReducedCost() const {
492          return reducedCost_;
493     }
494     /// Row lower
495     inline double* rowLower() const              {
496          return rowLower_;
497     }
498     inline const double* getRowLower() const     {
499          return rowLower_;
500     }
501     /// Row upper
502     inline double* rowUpper() const              {
503          return rowUpper_;
504     }
505     inline const double* getRowUpper() const     {
506          return rowUpper_;
507     }
508     //-------------------------------------------------------------------------
509     /**@name Changing bounds on variables and constraints */
510     //@{
511     /** Set an objective function coefficient */
512     void setObjectiveCoefficient( int elementIndex, double elementValue );
513     /** Set an objective function coefficient */
514     inline void setObjCoeff( int elementIndex, double elementValue ) {
515          setObjectiveCoefficient( elementIndex, elementValue);
516     }
517
518     /** Set a single column lower bound<br>
519         Use -DBL_MAX for -infinity. */
520     void setColumnLower( int elementIndex, double elementValue );
521
522     /** Set a single column upper bound<br>
523         Use DBL_MAX for infinity. */
524     void setColumnUpper( int elementIndex, double elementValue );
525
526     /** Set a single column lower and upper bound */
527     void setColumnBounds( int elementIndex,
528                           double lower, double upper );
529
530     /** Set the bounds on a number of columns simultaneously<br>
531         The default implementation just invokes setColLower() and
532         setColUpper() over and over again.
533         @param indexFirst,indexLast pointers to the beginning and after the
534            end of the array of the indices of the variables whose
535        <em>either</em> bound changes
536         @param boundList the new lower/upper bound pairs for the variables
537     */
538     void setColumnSetBounds(const int* indexFirst,
539                             const int* indexLast,
540                             const double* boundList);
541
542     /** Set a single column lower bound<br>
543         Use -DBL_MAX for -infinity. */
544     inline void setColLower( int elementIndex, double elementValue ) {
545          setColumnLower(elementIndex, elementValue);
546     }
547     /** Set a single column upper bound<br>
548         Use DBL_MAX for infinity. */
549     inline void setColUpper( int elementIndex, double elementValue ) {
550          setColumnUpper(elementIndex, elementValue);
551     }
552
553     /** Set a single column lower and upper bound */
554     inline void setColBounds( int elementIndex,
555                               double lower, double upper ) {
556          setColumnBounds(elementIndex, lower, upper);
557     }
558
559     /** Set the bounds on a number of columns simultaneously<br>
560         @param indexFirst,indexLast pointers to the beginning and after the
561            end of the array of the indices of the variables whose
562        <em>either</em> bound changes
563         @param boundList the new lower/upper bound pairs for the variables
564     */
565     inline void setColSetBounds(const int* indexFirst,
566                                 const int* indexLast,
567                                 const double* boundList) {
568          setColumnSetBounds(indexFirst, indexLast, boundList);
569     }
570
571     /** Set a single row lower bound<br>
572         Use -DBL_MAX for -infinity. */
573     void setRowLower( int elementIndex, double elementValue );
574
575     /** Set a single row upper bound<br>
576         Use DBL_MAX for infinity. */
577     void setRowUpper( int elementIndex, double elementValue ) ;
578
579     /** Set a single row lower and upper bound */
580     void setRowBounds( int elementIndex,
581                        double lower, double upper ) ;
582
583     /** Set the bounds on a number of rows simultaneously<br>
584         @param indexFirst,indexLast pointers to the beginning and after the
585            end of the array of the indices of the constraints whose
586        <em>either</em> bound changes
587         @param boundList the new lower/upper bound pairs for the constraints
588     */
589     void setRowSetBounds(const int* indexFirst,
590                          const int* indexLast,
591                          const double* boundList);
592
593     //@}
594     /// Scaling
595     inline const double * rowScale() const {
596          return rowScale_;
597     }
598     inline const double * columnScale() const {
599          return columnScale_;
600     }
601     inline const double * inverseRowScale() const {
602          return inverseRowScale_;
603     }
604     inline const double * inverseColumnScale() const {
605          return inverseColumnScale_;
606     }
607     inline double * mutableRowScale() const {
608          return rowScale_;
609     }
610     inline double * mutableColumnScale() const {
611          return columnScale_;
612     }
613     inline double * mutableInverseRowScale() const {
614          return inverseRowScale_;
615     }
616     inline double * mutableInverseColumnScale() const {
617          return inverseColumnScale_;
618     }
619     inline double * swapRowScale(double * newScale) {
620          double * oldScale = rowScale_;
621          rowScale_ = newScale;
622          return oldScale;
623     }
624     void setRowScale(double * scale) ;
625     void setColumnScale(double * scale);
626     /// Scaling of objective
627     inline double objectiveScale() const {
628          return objectiveScale_;
629     }
630     inline void setObjectiveScale(double value) {
631          objectiveScale_ = value;
632     }
633     /// Scaling of rhs and bounds
634     inline double rhsScale() const {
635          return rhsScale_;
636     }
637     inline void setRhsScale(double value) {
638          rhsScale_ = value;
639     }
640     /// Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3 auto, 4 auto-but-as-initialSolve-in-bab
641     void scaling(int mode = 1);
642     /** If we constructed a "really" scaled model then this reverses the operation.
643         Quantities may not be exactly as they were before due to rounding errors */
644     void unscale();
645     /// Gets scalingFlag
646     inline int scalingFlag() const {
647          return scalingFlag_;
648     }
649     /// Objective
650     inline double * objective() const {
651          if (objective_) {
652               double offset;
653               return objective_->gradient(NULL, NULL, offset, false);
654          } else {
655               return NULL;
656          }
657     }
658     inline double * objective(const double * solution, double & offset, bool refresh = true) const {
659          offset = 0.0;
660          if (objective_) {
661               return objective_->gradient(NULL, solution, offset, refresh);
662          } else {
663               return NULL;
664          }
665     }
666     inline const double * getObjCoefficients() const {
667          if (objective_) {
668               double offset;
669               return objective_->gradient(NULL, NULL, offset, false);
670          } else {
671               return NULL;
672          }
673     }
674     /// Row Objective
675     inline double * rowObjective() const         {
676          return rowObjective_;
677     }
678     inline const double * getRowObjCoefficients() const {
679          return rowObjective_;
680     }
681     /// Column Lower
682     inline double * columnLower() const          {
683          return columnLower_;
684     }
685     inline const double * getColLower() const    {
686          return columnLower_;
687     }
688     /// Column Upper
689     inline double * columnUpper() const          {
690          return columnUpper_;
691     }
692     inline const double * getColUpper() const    {
693          return columnUpper_;
694     }
695     /// Matrix (if not ClpPackedmatrix be careful about memory leak
696     inline CoinPackedMatrix * matrix() const {
697          if ( matrix_ == NULL ) return NULL;
698          else return matrix_->getPackedMatrix();
699     }
700     /// Number of elements in matrix
701     inline int getNumElements() const {
702          return matrix_->getNumElements();
703     }
704     /** Small element value - elements less than this set to zero,
705        default is 1.0e-20 */
706     inline double getSmallElementValue() const {
707          return smallElement_;
708     }
709     inline void setSmallElementValue(double value) {
710          smallElement_ = value;
711     }
712     /// Row Matrix
713     inline ClpMatrixBase * rowCopy() const       {
714          return rowCopy_;
715     }
716     /// Set new row matrix
717     void setNewRowCopy(ClpMatrixBase * newCopy);
718     /// Clp Matrix
719     inline ClpMatrixBase * clpMatrix() const     {
720          return matrix_;
721     }
722     /// Scaled ClpPackedMatrix
723     inline ClpPackedMatrix * clpScaledMatrix() const     {
724          return scaledMatrix_;
725     }
726     /// Sets pointer to scaled ClpPackedMatrix
727     inline void setClpScaledMatrix(ClpPackedMatrix * scaledMatrix) {
728          delete scaledMatrix_;
729          scaledMatrix_ = scaledMatrix;
730     }
731     /// Swaps pointer to scaled ClpPackedMatrix
732     inline ClpPackedMatrix * swapScaledMatrix(ClpPackedMatrix * scaledMatrix) {
733          ClpPackedMatrix * oldMatrix = scaledMatrix_;
734          scaledMatrix_ = scaledMatrix;
735          return oldMatrix;
736     }
737     /** Replace Clp Matrix (current is not deleted unless told to
738         and new is used)
739         So up to user to delete current.  This was used where
740         matrices were being rotated. ClpModel takes ownership.
741     */
742     void replaceMatrix(ClpMatrixBase * matrix, bool deleteCurrent = false);
743     /** Replace Clp Matrix (current is not deleted unless told to
744         and new is used) So up to user to delete current.  This was used where
745         matrices were being rotated.  This version changes CoinPackedMatrix
746         to ClpPackedMatrix.  ClpModel takes ownership.
747     */
748     inline void replaceMatrix(CoinPackedMatrix * newmatrix,
749                               bool deleteCurrent = false) {
750          replaceMatrix(new ClpPackedMatrix(newmatrix), deleteCurrent);
751     }
752     /// Objective value
753     inline double objectiveValue() const {
754          return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
755     }
756     inline void setObjectiveValue(double value) {
757          objectiveValue_ = (value + dblParam_[ClpObjOffset]) / optimizationDirection_;
758     }
759     inline double getObjValue() const {
760          return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
761     }
762     /// Integer information
763     inline char * integerInformation() const     {
764          return integerType_;
765     }
766     /** Infeasibility/unbounded ray (NULL returned if none/wrong)
767         Up to user to use delete [] on these arrays.  */
768     double * infeasibilityRay(bool fullRay=false) const;
769     double * unboundedRay() const;
770     /// For advanced users - no need to delete - sign not changed
771     inline double * ray() const
772     { return ray_;}
773     /// just test if infeasibility or unbounded Ray exists
774     inline bool rayExists() const {
775         return (ray_!=NULL);
776     }
777     /// just delete ray if exists
778     inline void deleteRay() {
779         delete [] ray_;
780         ray_=NULL;
781     }
782         /// Access internal ray storage. Users should call infeasibilityRay() or unboundedRay() instead.
783         inline const double * internalRay() const {
784                 return ray_;
785         }
786     /// See if status (i.e. basis) array exists (partly for OsiClp)
787     inline bool statusExists() const {
788          return (status_ != NULL);
789     }
790     /// Return address of status (i.e. basis) array (char[numberRows+numberColumns])
791     inline unsigned char *  statusArray() const {
792          return status_;
793     }
794     /** Return copy of status (i.e. basis) array (char[numberRows+numberColumns]),
795         use delete [] */
796     unsigned char *  statusCopy() const;
797     /// Copy in status (basis) vector
798     void copyinStatus(const unsigned char * statusArray);
799
800     /// User pointer for whatever reason
801     inline void setUserPointer (void * pointer) {
802          userPointer_ = pointer;
803     }
804     inline void * getUserPointer () const {
805          return userPointer_;
806     }
807     /// Trusted user pointer
808     inline void setTrustedUserPointer (ClpTrustedData * pointer) {
809          trustedUserPointer_ = pointer;
810     }
811     inline ClpTrustedData * getTrustedUserPointer () const {
812          return trustedUserPointer_;
813     }
814     /// What has changed in model (only for masochistic users)
815     inline int whatsChanged() const {
816          return whatsChanged_;
817     }
818     inline void setWhatsChanged(int value) {
819          whatsChanged_ = value;
820     }
821     /// Number of threads (not really being used)
822     inline int numberThreads() const {
823          return numberThreads_;
824     }
825     inline void setNumberThreads(int value) {
826          numberThreads_ = value;
827     }
828     //@}
829     /**@name Message handling */
830     //@{
831     /// Pass in Message handler (not deleted at end)
832     void passInMessageHandler(CoinMessageHandler * handler);
833     /// Pass in Message handler (not deleted at end) and return current
834     CoinMessageHandler * pushMessageHandler(CoinMessageHandler * handler,
835                                             bool & oldDefault);
836     /// back to previous message handler
837     void popMessageHandler(CoinMessageHandler * oldHandler, bool oldDefault);
838     /// Set language
839     void newLanguage(CoinMessages::Language language);
840     inline void setLanguage(CoinMessages::Language language) {
841          newLanguage(language);
842     }
843     /// Overrides message handler with a default one
844     void setDefaultMessageHandler();
845     /// Return handler
846     inline CoinMessageHandler * messageHandler() const       {
847          return handler_;
848     }
849     /// Return messages
850     inline CoinMessages messages() const                     {
851          return messages_;
852     }
853     /// Return pointer to messages
854     inline CoinMessages * messagesPointer()                  {
855          return & messages_;
856     }
857     /// Return Coin messages
858     inline CoinMessages coinMessages() const                  {
859          return coinMessages_;
860     }
861     /// Return pointer to Coin messages
862     inline CoinMessages * coinMessagesPointer()                  {
863          return & coinMessages_;
864     }
865     /** Amount of print out:
866         0 - none
867         1 - just final
868         2 - just factorizations
869         3 - as 2 plus a bit more
870         4 - verbose
871         above that 8,16,32 etc just for selective debug
872     */
873     inline void setLogLevel(int value)    {
874          handler_->setLogLevel(value);
875     }
876     inline int logLevel() const           {
877          return handler_->logLevel();
878     }
879     /// Return true if default handler
880     inline bool defaultHandler() const {
881          return defaultHandler_;
882     }
883     /// Pass in Event handler (cloned and deleted at end)
884     void passInEventHandler(const ClpEventHandler * eventHandler);
885     /// Event handler
886     inline ClpEventHandler * eventHandler() const {
887          return eventHandler_;
888     }
889     /// Thread specific random number generator
890     inline CoinThreadRandom * randomNumberGenerator() {
891          return &randomNumberGenerator_;
892     }
893     /// Thread specific random number generator
894     inline CoinThreadRandom & mutableRandomNumberGenerator() {
895          return randomNumberGenerator_;
896     }
897     /// Set seed for thread specific random number generator
898     inline void setRandomSeed(int value) {
899          randomNumberGenerator_.setSeed(value);
900     }
901     /// length of names (0 means no names0
902     inline int lengthNames() const {
903          return lengthNames_;
904     }
905#ifndef CLP_NO_STD
906     /// length of names (0 means no names0
907     inline void setLengthNames(int value) {
908          lengthNames_ = value;
909     }
910     /// Row names
911     inline const std::vector<std::string> * rowNames() const {
912          return &rowNames_;
913     }
914     inline const std::string& rowName(int iRow) const {
915          return rowNames_[iRow];
916     }
917     /// Return name or Rnnnnnnn
918     std::string getRowName(int iRow) const;
919     /// Column names
920     inline const std::vector<std::string> * columnNames() const {
921          return &columnNames_;
922     }
923     inline const std::string& columnName(int iColumn) const {
924          return columnNames_[iColumn];
925     }
926     /// Return name or Cnnnnnnn
927     std::string getColumnName(int iColumn) const;
928#endif
929     /// Objective methods
930     inline ClpObjective * objectiveAsObject() const {
931          return objective_;
932     }
933     void setObjective(ClpObjective * objective);
934     inline void setObjectivePointer(ClpObjective * newobjective) {
935          objective_ = newobjective;
936     }
937     /** Solve a problem with no elements - return status and
938         dual and primal infeasibilites */
939     int emptyProblem(int * infeasNumber = NULL, double * infeasSum = NULL, bool printMessage = true);
940
941     //@}
942
943     /**@name Matrix times vector methods
944        They can be faster if scalar is +- 1
945        These are covers so user need not worry about scaling
946        Also for simplex I am not using basic/non-basic split */
947     //@{
948     /** Return <code>y + A * x * scalar</code> in <code>y</code>.
949         @pre <code>x</code> must be of size <code>numColumns()</code>
950         @pre <code>y</code> must be of size <code>numRows()</code> */
951     void times(double scalar,
952                const double * x, double * y) const;
953     /** Return <code>y + x * scalar * A</code> in <code>y</code>.
954         @pre <code>x</code> must be of size <code>numRows()</code>
955         @pre <code>y</code> must be of size <code>numColumns()</code> */
956     void transposeTimes(double scalar,
957                         const double * x, double * y) const ;
958     //@}
959
960
961     //---------------------------------------------------------------------------
962     /**@name Parameter set/get methods
963
964        The set methods return true if the parameter was set to the given value,
965        false otherwise. There can be various reasons for failure: the given
966        parameter is not applicable for the solver (e.g., refactorization
967        frequency for the volume algorithm), the parameter is not yet implemented
968        for the solver or simply the value of the parameter is out of the range
969        the solver accepts. If a parameter setting call returns false check the
970        details of your solver.
971
972        The get methods return true if the given parameter is applicable for the
973        solver and is implemented. In this case the value of the parameter is
974        returned in the second argument. Otherwise they return false.
975
976        ** once it has been decided where solver sits this may be redone
977     */
978     //@{
979     /// Set an integer parameter
980     bool setIntParam(ClpIntParam key, int value) ;
981     /// Set an double parameter
982     bool setDblParam(ClpDblParam key, double value) ;
983#ifndef CLP_NO_STD
984     /// Set an string parameter
985     bool setStrParam(ClpStrParam key, const std::string & value);
986#endif
987     // Get an integer parameter
988     inline bool getIntParam(ClpIntParam key, int& value) const {
989          if (key < ClpLastIntParam) {
990               value = intParam_[key];
991               return true;
992          } else {
993               return false;
994          }
995     }
996     // Get an double parameter
997     inline bool getDblParam(ClpDblParam key, double& value) const {
998          if (key < ClpLastDblParam) {
999               value = dblParam_[key];
1000               return true;
1001          } else {
1002               return false;
1003          }
1004     }
1005#ifndef CLP_NO_STD
1006     // Get a string parameter
1007     inline bool getStrParam(ClpStrParam key, std::string& value) const {
1008          if (key < ClpLastStrParam) {
1009               value = strParam_[key];
1010               return true;
1011          } else {
1012               return false;
1013          }
1014     }
1015#endif
1016     /// Create C++ lines to get to current state
1017     void generateCpp( FILE * fp);
1018     /** For advanced options
1019         1 - Don't keep changing infeasibility weight
1020         2 - Keep nonLinearCost round solves
1021         4 - Force outgoing variables to exact bound (primal)
1022         8 - Safe to use dense initial factorization
1023         16 -Just use basic variables for operation if column generation
1024         32 -Create ray even in BAB
1025         64 -Treat problem as feasible until last minute (i.e. minimize infeasibilities)
1026         128 - Switch off all matrix sanity checks
1027         256 - No row copy
1028         512 - If not in values pass, solution guaranteed, skip as much as possible
1029         1024 - In branch and bound
1030         2048 - Don't bother to re-factorize if < 20 iterations
1031         4096 - Skip some optimality checks
1032         8192 - Do Primal when cleaning up primal
1033         16384 - In fast dual (so we can switch off things)
1034         32768 - called from Osi
1035         65536 - keep arrays around as much as possible (also use maximumR/C)
1036         131072 - transposeTimes is -1.0 and can skip basic and fixed
1037         262144 - extra copy of scaled matrix
1038         524288 - Clp fast dual
1039         1048576 - don't need to finish dual (can return 3)
1040         2097152 - zero costs!
1041         4194304 - don't scale integer variables
1042         NOTE - many applications can call Clp but there may be some short cuts
1043                which are taken which are not guaranteed safe from all applications.
1044                Vetted applications will have a bit set and the code may test this
1045                At present I expect a few such applications - if too many I will
1046                have to re-think.  It is up to application owner to change the code
1047                if she/he needs these short cuts.  I will not debug unless in Coin
1048                repository.  See COIN_CLP_VETTED comments.
1049         0x01000000 is Cbc (and in branch and bound)
1050         0x02000000 is in a different branch and bound
1051     */
1052     inline unsigned int specialOptions() const {
1053          return specialOptions_;
1054     }
1055     void setSpecialOptions(unsigned int value);
1056#define COIN_CBC_USING_CLP 0x01000000
1057     inline bool inCbcBranchAndBound() const {
1058          return (specialOptions_ & COIN_CBC_USING_CLP) != 0;
1059     }
1060     //@}
1061
1062     /**@name private or protected methods */
1063     //@{
1064protected:
1065     /// Does most of deletion (0 = all, 1 = most)
1066     void gutsOfDelete(int type);
1067     /** Does most of copying
1068         If trueCopy 0 then just points to arrays
1069         If -1 leaves as much as possible */
1070     void gutsOfCopy(const ClpModel & rhs, int trueCopy = 1);
1071     /// gets lower and upper bounds on rows
1072     void getRowBound(int iRow, double& lower, double& upper) const;
1073     /// puts in format I like - 4 array matrix - may make row copy
1074     void gutsOfLoadModel ( int numberRows, int numberColumns,
1075                            const double* collb, const double* colub,
1076                            const double* obj,
1077                            const double* rowlb, const double* rowub,
1078                            const double * rowObjective = NULL);
1079     /// Does much of scaling
1080     void gutsOfScaling();
1081     /// Objective value - always minimize
1082     inline double rawObjectiveValue() const {
1083          return objectiveValue_;
1084     }
1085     /// If we are using maximumRows_ and Columns_
1086     inline bool permanentArrays() const {
1087          return (specialOptions_ & 65536) != 0;
1088     }
1089     /// Start using maximumRows_ and Columns_
1090     void startPermanentArrays();
1091     /// Stop using maximumRows_ and Columns_
1092     void stopPermanentArrays();
1093     /// Create row names as char **
1094     const char * const * rowNamesAsChar() const;
1095     /// Create column names as char **
1096     const char * const * columnNamesAsChar() const;
1097     /// Delete char * version of names
1098     void deleteNamesAsChar(const char * const * names, int number) const;
1099     /// On stopped - sets secondary status
1100     void onStopped();
1101     //@}
1102
1103
1104////////////////// data //////////////////
1105protected:
1106
1107     /**@name data */
1108     //@{
1109     /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
1110     double optimizationDirection_;
1111     /// Array of double parameters
1112     double dblParam_[ClpLastDblParam];
1113     /// Objective value
1114     double objectiveValue_;
1115     /// Small element value
1116     double smallElement_;
1117     /// Scaling of objective
1118     double objectiveScale_;
1119     /// Scaling of rhs and bounds
1120     double rhsScale_;
1121     /// Number of rows
1122     int numberRows_;
1123     /// Number of columns
1124     int numberColumns_;
1125     /// Row activities
1126     double * rowActivity_;
1127     /// Column activities
1128     double * columnActivity_;
1129     /// Duals
1130     double * dual_;
1131     /// Reduced costs
1132     double * reducedCost_;
1133     /// Row lower
1134     double* rowLower_;
1135     /// Row upper
1136     double* rowUpper_;
1137     /// Objective
1138     ClpObjective * objective_;
1139     /// Row Objective (? sign)  - may be NULL
1140     double * rowObjective_;
1141     /// Column Lower
1142     double * columnLower_;
1143     /// Column Upper
1144     double * columnUpper_;
1145     /// Packed matrix
1146     ClpMatrixBase * matrix_;
1147     /// Row copy if wanted
1148     ClpMatrixBase * rowCopy_;
1149     /// Scaled packed matrix
1150     ClpPackedMatrix * scaledMatrix_;
1151     /// Infeasible/unbounded ray
1152     double * ray_;
1153     /// Row scale factors for matrix
1154     double * rowScale_;
1155     /// Column scale factors
1156     double * columnScale_;
1157     /// Inverse row scale factors for matrix (end of rowScale_)
1158     double * inverseRowScale_;
1159     /// Inverse column scale factors for matrix (end of columnScale_)
1160     double * inverseColumnScale_;
1161     /** Scale flag, 0 none, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic,
1162         5 geometric on rows */
1163     int scalingFlag_;
1164     /** Status (i.e. basis) Region.  I know that not all algorithms need a status
1165         array, but it made sense for things like crossover and put
1166         all permanent stuff in one place.  No assumption is made
1167         about what is in status array (although it might be good to reserve
1168         bottom 3 bits (i.e. 0-7 numeric) for classic status).  This
1169         is number of columns + number of rows long (in that order).
1170     */
1171     unsigned char * status_;
1172     /// Integer information
1173     char * integerType_;
1174     /// User pointer for whatever reason
1175     void * userPointer_;
1176     /// Trusted user pointer e.g. for heuristics
1177     ClpTrustedData * trustedUserPointer_;
1178     /// Array of integer parameters
1179     int intParam_[ClpLastIntParam];
1180     /// Number of iterations
1181     int numberIterations_;
1182     /** Solve type - 1 simplex, 2 simplex interface, 3 Interior.*/
1183     int solveType_;
1184     /** Whats changed since last solve.  This is a work in progress
1185         It is designed so careful people can make go faster.
1186         It is only used when startFinishOptions used in dual or primal.
1187         Bit 1 - number of rows/columns has not changed (so work arrays valid)
1188             2 - matrix has not changed
1189             4 - if matrix has changed only by adding rows
1190             8 - if matrix has changed only by adding columns
1191            16 - row lbs not changed
1192            32 - row ubs not changed
1193            64 - column objective not changed
1194           128 - column lbs not changed
1195           256 - column ubs not changed
1196       512 - basis not changed (up to user to set this to 0)
1197             top bits may be used internally
1198       shift by 65336 is 3 all same, 1 all except col bounds
1199     */
1200#define ROW_COLUMN_COUNTS_SAME 1
1201#define MATRIX_SAME 2
1202#define MATRIX_JUST_ROWS_ADDED 4
1203#define MATRIX_JUST_COLUMNS_ADDED 8
1204#define ROW_LOWER_SAME 16
1205#define ROW_UPPER_SAME 32
1206#define OBJECTIVE_SAME 64
1207#define COLUMN_LOWER_SAME 128
1208#define COLUMN_UPPER_SAME 256
1209#define BASIS_SAME 512
1210#define ALL_SAME 65339
1211#define ALL_SAME_EXCEPT_COLUMN_BOUNDS 65337
1212     unsigned int whatsChanged_;
1213     /// Status of problem
1214     int problemStatus_;
1215     /// Secondary status of problem
1216     int secondaryStatus_;
1217     /// length of names (0 means no names)
1218     int lengthNames_;
1219     /// Number of threads (not very operational)
1220     int numberThreads_;
1221     /** For advanced options
1222         See get and set for meaning
1223     */
1224     unsigned int specialOptions_;
1225     /// Message handler
1226     CoinMessageHandler * handler_;
1227     /// Flag to say if default handler (so delete)
1228     bool defaultHandler_;
1229     /// Thread specific random number generator
1230     CoinThreadRandom randomNumberGenerator_;
1231     /// Event handler
1232     ClpEventHandler * eventHandler_;
1233#ifndef CLP_NO_STD
1234     /// Row names
1235     std::vector<std::string> rowNames_;
1236     /// Column names
1237     std::vector<std::string> columnNames_;
1238#endif
1239     /// Messages
1240     CoinMessages messages_;
1241     /// Coin messages
1242     CoinMessages coinMessages_;
1243     /// Maximum number of columns in model
1244     int maximumColumns_;
1245     /// Maximum number of rows in model
1246     int maximumRows_;
1247     /// Maximum number of columns (internal arrays) in model
1248     int maximumInternalColumns_;
1249     /// Maximum number of rows (internal arrays) in model
1250     int maximumInternalRows_;
1251     /// Base packed matrix
1252     CoinPackedMatrix baseMatrix_;
1253     /// Base row copy
1254     CoinPackedMatrix baseRowCopy_;
1255     /// Saved row scale factors for matrix
1256     double * savedRowScale_;
1257     /// Saved column scale factors
1258     double * savedColumnScale_;
1259#ifndef CLP_NO_STD
1260     /// Array of string parameters
1261     std::string strParam_[ClpLastStrParam];
1262#endif
1263     //@}
1264};
1265/** This is a tiny class where data can be saved round calls.
1266 */
1267class ClpDataSave {
1268
1269public:
1270     /**@name Constructors and destructor
1271      */
1272     //@{
1273     /// Default constructor
1274     ClpDataSave (  );
1275
1276     /// Copy constructor.
1277     ClpDataSave(const ClpDataSave &);
1278     /// Assignment operator. This copies the data
1279     ClpDataSave & operator=(const ClpDataSave & rhs);
1280     /// Destructor
1281     ~ClpDataSave (  );
1282
1283     //@}
1284
1285////////////////// data //////////////////
1286public:
1287
1288     /**@name data - with same names as in other classes*/
1289     //@{
1290     double dualBound_;
1291     double infeasibilityCost_;
1292     double pivotTolerance_;
1293     double zeroFactorizationTolerance_;
1294     double zeroSimplexTolerance_;
1295     double acceptablePivot_;
1296     double objectiveScale_;
1297     int sparseThreshold_;
1298     int perturbation_;
1299     int forceFactorization_;
1300     int scalingFlag_;
1301     unsigned int specialOptions_;
1302     //@}
1303};
1304
1305#endif
Note: See TracBrowser for help on using the repository browser.