source: stable/1.15/Clp/src/ClpModel.hpp @ 1941

Last change on this file since 1941 was 1941, checked in by stefan, 6 years ago

sync with trunk rev 1940

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 48.7 KB
Line 
1/* $Id: ClpModel.hpp 1941 2013-04-10 16:52:27Z stefan $ */
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         100 up - translation of enum from ClpEventHandler
423     */
424     inline int secondaryStatus() const            {
425          return secondaryStatus_;
426     }
427     inline void setSecondaryStatus(int newstatus) {
428          secondaryStatus_ = newstatus;
429     }
430     /// Are there a numerical difficulties?
431     inline bool isAbandoned() const             {
432          return problemStatus_ == 4;
433     }
434     /// Is optimality proven?
435     inline bool isProvenOptimal() const         {
436          return problemStatus_ == 0;
437     }
438     /// Is primal infeasiblity proven?
439     inline bool isProvenPrimalInfeasible() const {
440          return problemStatus_ == 1;
441     }
442     /// Is dual infeasiblity proven?
443     inline bool isProvenDualInfeasible() const  {
444          return problemStatus_ == 2;
445     }
446     /// Is the given primal objective limit reached?
447     bool isPrimalObjectiveLimitReached() const ;
448     /// Is the given dual objective limit reached?
449     bool isDualObjectiveLimitReached() const ;
450     /// Iteration limit reached?
451     inline bool isIterationLimitReached() const {
452          return problemStatus_ == 3;
453     }
454     /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
455     inline double optimizationDirection() const {
456          return  optimizationDirection_;
457     }
458     inline double getObjSense() const    {
459          return optimizationDirection_;
460     }
461     void setOptimizationDirection(double value);
462     /// Primal row solution
463     inline double * primalRowSolution() const    {
464          return rowActivity_;
465     }
466     inline const double * getRowActivity() const {
467          return rowActivity_;
468     }
469     /// Primal column solution
470     inline double * primalColumnSolution() const {
471          return columnActivity_;
472     }
473     inline const double * getColSolution() const {
474          return columnActivity_;
475     }
476     inline void setColSolution(const double * input) {
477          memcpy(columnActivity_, input, numberColumns_ * sizeof(double));
478     }
479     /// Dual row solution
480     inline double * dualRowSolution() const      {
481          return dual_;
482     }
483     inline const double * getRowPrice() const    {
484          return dual_;
485     }
486     /// Reduced costs
487     inline double * dualColumnSolution() const   {
488          return reducedCost_;
489     }
490     inline const double * getReducedCost() const {
491          return reducedCost_;
492     }
493     /// Row lower
494     inline double* rowLower() const              {
495          return rowLower_;
496     }
497     inline const double* getRowLower() const     {
498          return rowLower_;
499     }
500     /// Row upper
501     inline double* rowUpper() const              {
502          return rowUpper_;
503     }
504     inline const double* getRowUpper() const     {
505          return rowUpper_;
506     }
507     //-------------------------------------------------------------------------
508     /**@name Changing bounds on variables and constraints */
509     //@{
510     /** Set an objective function coefficient */
511     void setObjectiveCoefficient( int elementIndex, double elementValue );
512     /** Set an objective function coefficient */
513     inline void setObjCoeff( int elementIndex, double elementValue ) {
514          setObjectiveCoefficient( elementIndex, elementValue);
515     }
516
517     /** Set a single column lower bound<br>
518         Use -DBL_MAX for -infinity. */
519     void setColumnLower( int elementIndex, double elementValue );
520
521     /** Set a single column upper bound<br>
522         Use DBL_MAX for infinity. */
523     void setColumnUpper( int elementIndex, double elementValue );
524
525     /** Set a single column lower and upper bound */
526     void setColumnBounds( int elementIndex,
527                           double lower, double upper );
528
529     /** Set the bounds on a number of columns simultaneously<br>
530         The default implementation just invokes setColLower() and
531         setColUpper() over and over again.
532         @param indexFirst,indexLast pointers to the beginning and after the
533            end of the array of the indices of the variables whose
534        <em>either</em> bound changes
535         @param boundList the new lower/upper bound pairs for the variables
536     */
537     void setColumnSetBounds(const int* indexFirst,
538                             const int* indexLast,
539                             const double* boundList);
540
541     /** Set a single column lower bound<br>
542         Use -DBL_MAX for -infinity. */
543     inline void setColLower( int elementIndex, double elementValue ) {
544          setColumnLower(elementIndex, elementValue);
545     }
546     /** Set a single column upper bound<br>
547         Use DBL_MAX for infinity. */
548     inline void setColUpper( int elementIndex, double elementValue ) {
549          setColumnUpper(elementIndex, elementValue);
550     }
551
552     /** Set a single column lower and upper bound */
553     inline void setColBounds( int elementIndex,
554                               double lower, double upper ) {
555          setColumnBounds(elementIndex, lower, upper);
556     }
557
558     /** Set the bounds on a number of columns simultaneously<br>
559         @param indexFirst,indexLast pointers to the beginning and after the
560            end of the array of the indices of the variables whose
561        <em>either</em> bound changes
562         @param boundList the new lower/upper bound pairs for the variables
563     */
564     inline void setColSetBounds(const int* indexFirst,
565                                 const int* indexLast,
566                                 const double* boundList) {
567          setColumnSetBounds(indexFirst, indexLast, boundList);
568     }
569
570     /** Set a single row lower bound<br>
571         Use -DBL_MAX for -infinity. */
572     void setRowLower( int elementIndex, double elementValue );
573
574     /** Set a single row upper bound<br>
575         Use DBL_MAX for infinity. */
576     void setRowUpper( int elementIndex, double elementValue ) ;
577
578     /** Set a single row lower and upper bound */
579     void setRowBounds( int elementIndex,
580                        double lower, double upper ) ;
581
582     /** Set the bounds on a number of rows simultaneously<br>
583         @param indexFirst,indexLast pointers to the beginning and after the
584            end of the array of the indices of the constraints whose
585        <em>either</em> bound changes
586         @param boundList the new lower/upper bound pairs for the constraints
587     */
588     void setRowSetBounds(const int* indexFirst,
589                          const int* indexLast,
590                          const double* boundList);
591
592     //@}
593     /// Scaling
594     inline const double * rowScale() const {
595          return rowScale_;
596     }
597     inline const double * columnScale() const {
598          return columnScale_;
599     }
600     inline const double * inverseRowScale() const {
601          return inverseRowScale_;
602     }
603     inline const double * inverseColumnScale() const {
604          return inverseColumnScale_;
605     }
606     inline double * mutableRowScale() const {
607          return rowScale_;
608     }
609     inline double * mutableColumnScale() const {
610          return columnScale_;
611     }
612     inline double * mutableInverseRowScale() const {
613          return inverseRowScale_;
614     }
615     inline double * mutableInverseColumnScale() const {
616          return inverseColumnScale_;
617     }
618     inline double * swapRowScale(double * newScale) {
619          double * oldScale = rowScale_;
620          rowScale_ = newScale;
621          return oldScale;
622     }
623     void setRowScale(double * scale) ;
624     void setColumnScale(double * scale);
625     /// Scaling of objective
626     inline double objectiveScale() const {
627          return objectiveScale_;
628     }
629     inline void setObjectiveScale(double value) {
630          objectiveScale_ = value;
631     }
632     /// Scaling of rhs and bounds
633     inline double rhsScale() const {
634          return rhsScale_;
635     }
636     inline void setRhsScale(double value) {
637          rhsScale_ = value;
638     }
639     /// Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3 auto, 4 auto-but-as-initialSolve-in-bab
640     void scaling(int mode = 1);
641     /** If we constructed a "really" scaled model then this reverses the operation.
642         Quantities may not be exactly as they were before due to rounding errors */
643     void unscale();
644     /// Gets scalingFlag
645     inline int scalingFlag() const {
646          return scalingFlag_;
647     }
648     /// Objective
649     inline double * objective() const {
650          if (objective_) {
651               double offset;
652               return objective_->gradient(NULL, NULL, offset, false);
653          } else {
654               return NULL;
655          }
656     }
657     inline double * objective(const double * solution, double & offset, bool refresh = true) const {
658          offset = 0.0;
659          if (objective_) {
660               return objective_->gradient(NULL, solution, offset, refresh);
661          } else {
662               return NULL;
663          }
664     }
665     inline const double * getObjCoefficients() const {
666          if (objective_) {
667               double offset;
668               return objective_->gradient(NULL, NULL, offset, false);
669          } else {
670               return NULL;
671          }
672     }
673     /// Row Objective
674     inline double * rowObjective() const         {
675          return rowObjective_;
676     }
677     inline const double * getRowObjCoefficients() const {
678          return rowObjective_;
679     }
680     /// Column Lower
681     inline double * columnLower() const          {
682          return columnLower_;
683     }
684     inline const double * getColLower() const    {
685          return columnLower_;
686     }
687     /// Column Upper
688     inline double * columnUpper() const          {
689          return columnUpper_;
690     }
691     inline const double * getColUpper() const    {
692          return columnUpper_;
693     }
694     /// Matrix (if not ClpPackedmatrix be careful about memory leak
695     inline CoinPackedMatrix * matrix() const {
696          if ( matrix_ == NULL ) return NULL;
697          else return matrix_->getPackedMatrix();
698     }
699     /// Number of elements in matrix
700     inline int getNumElements() const {
701          return matrix_->getNumElements();
702     }
703     /** Small element value - elements less than this set to zero,
704        default is 1.0e-20 */
705     inline double getSmallElementValue() const {
706          return smallElement_;
707     }
708     inline void setSmallElementValue(double value) {
709          smallElement_ = value;
710     }
711     /// Row Matrix
712     inline ClpMatrixBase * rowCopy() const       {
713          return rowCopy_;
714     }
715     /// Set new row matrix
716     void setNewRowCopy(ClpMatrixBase * newCopy);
717     /// Clp Matrix
718     inline ClpMatrixBase * clpMatrix() const     {
719          return matrix_;
720     }
721     /// Scaled ClpPackedMatrix
722     inline ClpPackedMatrix * clpScaledMatrix() const     {
723          return scaledMatrix_;
724     }
725     /// Sets pointer to scaled ClpPackedMatrix
726     inline void setClpScaledMatrix(ClpPackedMatrix * scaledMatrix) {
727          delete scaledMatrix_;
728          scaledMatrix_ = scaledMatrix;
729     }
730     /// Swaps pointer to scaled ClpPackedMatrix
731     inline ClpPackedMatrix * swapScaledMatrix(ClpPackedMatrix * scaledMatrix) {
732          ClpPackedMatrix * oldMatrix = scaledMatrix_;
733          scaledMatrix_ = scaledMatrix;
734          return oldMatrix;
735     }
736     /** Replace Clp Matrix (current is not deleted unless told to
737         and new is used)
738         So up to user to delete current.  This was used where
739         matrices were being rotated. ClpModel takes ownership.
740     */
741     void replaceMatrix(ClpMatrixBase * matrix, bool deleteCurrent = false);
742     /** Replace Clp Matrix (current is not deleted unless told to
743         and new is used) So up to user to delete current.  This was used where
744         matrices were being rotated.  This version changes CoinPackedMatrix
745         to ClpPackedMatrix.  ClpModel takes ownership.
746     */
747     inline void replaceMatrix(CoinPackedMatrix * newmatrix,
748                               bool deleteCurrent = false) {
749          replaceMatrix(new ClpPackedMatrix(newmatrix), deleteCurrent);
750     }
751     /// Objective value
752     inline double objectiveValue() const {
753          return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
754     }
755     inline void setObjectiveValue(double value) {
756          objectiveValue_ = (value + dblParam_[ClpObjOffset]) / optimizationDirection_;
757     }
758     inline double getObjValue() const {
759          return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
760     }
761     /// Integer information
762     inline char * integerInformation() const     {
763          return integerType_;
764     }
765     /** Infeasibility/unbounded ray (NULL returned if none/wrong)
766         Up to user to use delete [] on these arrays.  */
767     double * infeasibilityRay(bool fullRay=false) const;
768     double * unboundedRay() const;
769     /// For advanced users - no need to delete - sign not changed
770     inline double * ray() const
771     { return ray_;}
772     /// just test if infeasibility or unbounded Ray exists
773     inline bool rayExists() const {
774         return (ray_!=NULL);
775     }
776     /// just delete ray if exists
777     inline void deleteRay() {
778         delete [] ray_;
779         ray_=NULL;
780     }
781         /// Access internal ray storage. Users should call infeasibilityRay() or unboundedRay() instead.
782         inline const double * internalRay() const {
783                 return ray_;
784         }
785     /// See if status (i.e. basis) array exists (partly for OsiClp)
786     inline bool statusExists() const {
787          return (status_ != NULL);
788     }
789     /// Return address of status (i.e. basis) array (char[numberRows+numberColumns])
790     inline unsigned char *  statusArray() const {
791          return status_;
792     }
793     /** Return copy of status (i.e. basis) array (char[numberRows+numberColumns]),
794         use delete [] */
795     unsigned char *  statusCopy() const;
796     /// Copy in status (basis) vector
797     void copyinStatus(const unsigned char * statusArray);
798
799     /// User pointer for whatever reason
800     inline void setUserPointer (void * pointer) {
801          userPointer_ = pointer;
802     }
803     inline void * getUserPointer () const {
804          return userPointer_;
805     }
806     /// Trusted user pointer
807     inline void setTrustedUserPointer (ClpTrustedData * pointer) {
808          trustedUserPointer_ = pointer;
809     }
810     inline ClpTrustedData * getTrustedUserPointer () const {
811          return trustedUserPointer_;
812     }
813     /// What has changed in model (only for masochistic users)
814     inline int whatsChanged() const {
815          return whatsChanged_;
816     }
817     inline void setWhatsChanged(int value) {
818          whatsChanged_ = value;
819     }
820     /// Number of threads (not really being used)
821     inline int numberThreads() const {
822          return numberThreads_;
823     }
824     inline void setNumberThreads(int value) {
825          numberThreads_ = value;
826     }
827     //@}
828     /**@name Message handling */
829     //@{
830     /// Pass in Message handler (not deleted at end)
831     void passInMessageHandler(CoinMessageHandler * handler);
832     /// Pass in Message handler (not deleted at end) and return current
833     CoinMessageHandler * pushMessageHandler(CoinMessageHandler * handler,
834                                             bool & oldDefault);
835     /// back to previous message handler
836     void popMessageHandler(CoinMessageHandler * oldHandler, bool oldDefault);
837     /// Set language
838     void newLanguage(CoinMessages::Language language);
839     inline void setLanguage(CoinMessages::Language language) {
840          newLanguage(language);
841     }
842     /// Overrides message handler with a default one
843     void setDefaultMessageHandler();
844     /// Return handler
845     inline CoinMessageHandler * messageHandler() const       {
846          return handler_;
847     }
848     /// Return messages
849     inline CoinMessages messages() const                     {
850          return messages_;
851     }
852     /// Return pointer to messages
853     inline CoinMessages * messagesPointer()                  {
854          return & messages_;
855     }
856     /// Return Coin messages
857     inline CoinMessages coinMessages() const                  {
858          return coinMessages_;
859     }
860     /// Return pointer to Coin messages
861     inline CoinMessages * coinMessagesPointer()                  {
862          return & coinMessages_;
863     }
864     /** Amount of print out:
865         0 - none
866         1 - just final
867         2 - just factorizations
868         3 - as 2 plus a bit more
869         4 - verbose
870         above that 8,16,32 etc just for selective debug
871     */
872     inline void setLogLevel(int value)    {
873          handler_->setLogLevel(value);
874     }
875     inline int logLevel() const           {
876          return handler_->logLevel();
877     }
878     /// Return true if default handler
879     inline bool defaultHandler() const {
880          return defaultHandler_;
881     }
882     /// Pass in Event handler (cloned and deleted at end)
883     void passInEventHandler(const ClpEventHandler * eventHandler);
884     /// Event handler
885     inline ClpEventHandler * eventHandler() const {
886          return eventHandler_;
887     }
888     /// Thread specific random number generator
889     inline CoinThreadRandom * randomNumberGenerator() {
890          return &randomNumberGenerator_;
891     }
892     /// Thread specific random number generator
893     inline CoinThreadRandom & mutableRandomNumberGenerator() {
894          return randomNumberGenerator_;
895     }
896     /// Set seed for thread specific random number generator
897     inline void setRandomSeed(int value) {
898          randomNumberGenerator_.setSeed(value);
899     }
900     /// length of names (0 means no names0
901     inline int lengthNames() const {
902          return lengthNames_;
903     }
904#ifndef CLP_NO_STD
905     /// length of names (0 means no names0
906     inline void setLengthNames(int value) {
907          lengthNames_ = value;
908     }
909     /// Row names
910     inline const std::vector<std::string> * rowNames() const {
911          return &rowNames_;
912     }
913     inline const std::string& rowName(int iRow) const {
914          return rowNames_[iRow];
915     }
916     /// Return name or Rnnnnnnn
917     std::string getRowName(int iRow) const;
918     /// Column names
919     inline const std::vector<std::string> * columnNames() const {
920          return &columnNames_;
921     }
922     inline const std::string& columnName(int iColumn) const {
923          return columnNames_[iColumn];
924     }
925     /// Return name or Cnnnnnnn
926     std::string getColumnName(int iColumn) const;
927#endif
928     /// Objective methods
929     inline ClpObjective * objectiveAsObject() const {
930          return objective_;
931     }
932     void setObjective(ClpObjective * objective);
933     inline void setObjectivePointer(ClpObjective * newobjective) {
934          objective_ = newobjective;
935     }
936     /** Solve a problem with no elements - return status and
937         dual and primal infeasibilites */
938     int emptyProblem(int * infeasNumber = NULL, double * infeasSum = NULL, bool printMessage = true);
939
940     //@}
941
942     /**@name Matrix times vector methods
943        They can be faster if scalar is +- 1
944        These are covers so user need not worry about scaling
945        Also for simplex I am not using basic/non-basic split */
946     //@{
947     /** Return <code>y + A * x * scalar</code> in <code>y</code>.
948         @pre <code>x</code> must be of size <code>numColumns()</code>
949         @pre <code>y</code> must be of size <code>numRows()</code> */
950     void times(double scalar,
951                const double * x, double * y) const;
952     /** Return <code>y + x * scalar * A</code> in <code>y</code>.
953         @pre <code>x</code> must be of size <code>numRows()</code>
954         @pre <code>y</code> must be of size <code>numColumns()</code> */
955     void transposeTimes(double scalar,
956                         const double * x, double * y) const ;
957     //@}
958
959
960     //---------------------------------------------------------------------------
961     /**@name Parameter set/get methods
962
963        The set methods return true if the parameter was set to the given value,
964        false otherwise. There can be various reasons for failure: the given
965        parameter is not applicable for the solver (e.g., refactorization
966        frequency for the volume algorithm), the parameter is not yet implemented
967        for the solver or simply the value of the parameter is out of the range
968        the solver accepts. If a parameter setting call returns false check the
969        details of your solver.
970
971        The get methods return true if the given parameter is applicable for the
972        solver and is implemented. In this case the value of the parameter is
973        returned in the second argument. Otherwise they return false.
974
975        ** once it has been decided where solver sits this may be redone
976     */
977     //@{
978     /// Set an integer parameter
979     bool setIntParam(ClpIntParam key, int value) ;
980     /// Set an double parameter
981     bool setDblParam(ClpDblParam key, double value) ;
982#ifndef CLP_NO_STD
983     /// Set an string parameter
984     bool setStrParam(ClpStrParam key, const std::string & value);
985#endif
986     // Get an integer parameter
987     inline bool getIntParam(ClpIntParam key, int& value) const {
988          if (key < ClpLastIntParam) {
989               value = intParam_[key];
990               return true;
991          } else {
992               return false;
993          }
994     }
995     // Get an double parameter
996     inline bool getDblParam(ClpDblParam key, double& value) const {
997          if (key < ClpLastDblParam) {
998               value = dblParam_[key];
999               return true;
1000          } else {
1001               return false;
1002          }
1003     }
1004#ifndef CLP_NO_STD
1005     // Get a string parameter
1006     inline bool getStrParam(ClpStrParam key, std::string& value) const {
1007          if (key < ClpLastStrParam) {
1008               value = strParam_[key];
1009               return true;
1010          } else {
1011               return false;
1012          }
1013     }
1014#endif
1015     /// Create C++ lines to get to current state
1016     void generateCpp( FILE * fp);
1017     /** For advanced options
1018         1 - Don't keep changing infeasibility weight
1019         2 - Keep nonLinearCost round solves
1020         4 - Force outgoing variables to exact bound (primal)
1021         8 - Safe to use dense initial factorization
1022         16 -Just use basic variables for operation if column generation
1023         32 -Create ray even in BAB
1024         64 -Treat problem as feasible until last minute (i.e. minimize infeasibilities)
1025         128 - Switch off all matrix sanity checks
1026         256 - No row copy
1027         512 - If not in values pass, solution guaranteed, skip as much as possible
1028         1024 - In branch and bound
1029         2048 - Don't bother to re-factorize if < 20 iterations
1030         4096 - Skip some optimality checks
1031         8192 - Do Primal when cleaning up primal
1032         16384 - In fast dual (so we can switch off things)
1033         32768 - called from Osi
1034         65536 - keep arrays around as much as possible (also use maximumR/C)
1035         131072 - transposeTimes is -1.0 and can skip basic and fixed
1036         262144 - extra copy of scaled matrix
1037         524288 - Clp fast dual
1038         1048576 - don't need to finish dual (can return 3)
1039         2097152 - zero costs!
1040         NOTE - many applications can call Clp but there may be some short cuts
1041                which are taken which are not guaranteed safe from all applications.
1042                Vetted applications will have a bit set and the code may test this
1043                At present I expect a few such applications - if too many I will
1044                have to re-think.  It is up to application owner to change the code
1045                if she/he needs these short cuts.  I will not debug unless in Coin
1046                repository.  See COIN_CLP_VETTED comments.
1047         0x01000000 is Cbc (and in branch and bound)
1048         0x02000000 is in a different branch and bound
1049     */
1050     inline unsigned int specialOptions() const {
1051          return specialOptions_;
1052     }
1053     void setSpecialOptions(unsigned int value);
1054#define COIN_CBC_USING_CLP 0x01000000
1055     inline bool inCbcBranchAndBound() const {
1056          return (specialOptions_ & COIN_CBC_USING_CLP) != 0;
1057     }
1058     //@}
1059
1060     /**@name private or protected methods */
1061     //@{
1062protected:
1063     /// Does most of deletion (0 = all, 1 = most)
1064     void gutsOfDelete(int type);
1065     /** Does most of copying
1066         If trueCopy 0 then just points to arrays
1067         If -1 leaves as much as possible */
1068     void gutsOfCopy(const ClpModel & rhs, int trueCopy = 1);
1069     /// gets lower and upper bounds on rows
1070     void getRowBound(int iRow, double& lower, double& upper) const;
1071     /// puts in format I like - 4 array matrix - may make row copy
1072     void gutsOfLoadModel ( int numberRows, int numberColumns,
1073                            const double* collb, const double* colub,
1074                            const double* obj,
1075                            const double* rowlb, const double* rowub,
1076                            const double * rowObjective = NULL);
1077     /// Does much of scaling
1078     void gutsOfScaling();
1079     /// Objective value - always minimize
1080     inline double rawObjectiveValue() const {
1081          return objectiveValue_;
1082     }
1083     /// If we are using maximumRows_ and Columns_
1084     inline bool permanentArrays() const {
1085          return (specialOptions_ & 65536) != 0;
1086     }
1087     /// Start using maximumRows_ and Columns_
1088     void startPermanentArrays();
1089     /// Stop using maximumRows_ and Columns_
1090     void stopPermanentArrays();
1091     /// Create row names as char **
1092     const char * const * rowNamesAsChar() const;
1093     /// Create column names as char **
1094     const char * const * columnNamesAsChar() const;
1095     /// Delete char * version of names
1096     void deleteNamesAsChar(const char * const * names, int number) const;
1097     /// On stopped - sets secondary status
1098     void onStopped();
1099     //@}
1100
1101
1102////////////////// data //////////////////
1103protected:
1104
1105     /**@name data */
1106     //@{
1107     /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
1108     double optimizationDirection_;
1109     /// Array of double parameters
1110     double dblParam_[ClpLastDblParam];
1111     /// Objective value
1112     double objectiveValue_;
1113     /// Small element value
1114     double smallElement_;
1115     /// Scaling of objective
1116     double objectiveScale_;
1117     /// Scaling of rhs and bounds
1118     double rhsScale_;
1119     /// Number of rows
1120     int numberRows_;
1121     /// Number of columns
1122     int numberColumns_;
1123     /// Row activities
1124     double * rowActivity_;
1125     /// Column activities
1126     double * columnActivity_;
1127     /// Duals
1128     double * dual_;
1129     /// Reduced costs
1130     double * reducedCost_;
1131     /// Row lower
1132     double* rowLower_;
1133     /// Row upper
1134     double* rowUpper_;
1135     /// Objective
1136     ClpObjective * objective_;
1137     /// Row Objective (? sign)  - may be NULL
1138     double * rowObjective_;
1139     /// Column Lower
1140     double * columnLower_;
1141     /// Column Upper
1142     double * columnUpper_;
1143     /// Packed matrix
1144     ClpMatrixBase * matrix_;
1145     /// Row copy if wanted
1146     ClpMatrixBase * rowCopy_;
1147     /// Scaled packed matrix
1148     ClpPackedMatrix * scaledMatrix_;
1149     /// Infeasible/unbounded ray
1150     double * ray_;
1151     /// Row scale factors for matrix
1152     double * rowScale_;
1153     /// Column scale factors
1154     double * columnScale_;
1155     /// Inverse row scale factors for matrix (end of rowScale_)
1156     double * inverseRowScale_;
1157     /// Inverse column scale factors for matrix (end of columnScale_)
1158     double * inverseColumnScale_;
1159     /** Scale flag, 0 none, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic,
1160         5 geometric on rows */
1161     int scalingFlag_;
1162     /** Status (i.e. basis) Region.  I know that not all algorithms need a status
1163         array, but it made sense for things like crossover and put
1164         all permanent stuff in one place.  No assumption is made
1165         about what is in status array (although it might be good to reserve
1166         bottom 3 bits (i.e. 0-7 numeric) for classic status).  This
1167         is number of columns + number of rows long (in that order).
1168     */
1169     unsigned char * status_;
1170     /// Integer information
1171     char * integerType_;
1172     /// User pointer for whatever reason
1173     void * userPointer_;
1174     /// Trusted user pointer e.g. for heuristics
1175     ClpTrustedData * trustedUserPointer_;
1176     /// Array of integer parameters
1177     int intParam_[ClpLastIntParam];
1178     /// Number of iterations
1179     int numberIterations_;
1180     /** Solve type - 1 simplex, 2 simplex interface, 3 Interior.*/
1181     int solveType_;
1182     /** Whats changed since last solve.  This is a work in progress
1183         It is designed so careful people can make go faster.
1184         It is only used when startFinishOptions used in dual or primal.
1185         Bit 1 - number of rows/columns has not changed (so work arrays valid)
1186             2 - matrix has not changed
1187             4 - if matrix has changed only by adding rows
1188             8 - if matrix has changed only by adding columns
1189            16 - row lbs not changed
1190            32 - row ubs not changed
1191            64 - column objective not changed
1192           128 - column lbs not changed
1193           256 - column ubs not changed
1194       512 - basis not changed (up to user to set this to 0)
1195             top bits may be used internally
1196       shift by 65336 is 3 all same, 1 all except col bounds
1197     */
1198#define ROW_COLUMN_COUNTS_SAME 1
1199#define MATRIX_SAME 2
1200#define MATRIX_JUST_ROWS_ADDED 4
1201#define MATRIX_JUST_COLUMNS_ADDED 8
1202#define ROW_LOWER_SAME 16
1203#define ROW_UPPER_SAME 32
1204#define OBJECTIVE_SAME 64
1205#define COLUMN_LOWER_SAME 128
1206#define COLUMN_UPPER_SAME 256
1207#define BASIS_SAME 512
1208#define ALL_SAME 65339
1209#define ALL_SAME_EXCEPT_COLUMN_BOUNDS 65337
1210     unsigned int whatsChanged_;
1211     /// Status of problem
1212     int problemStatus_;
1213     /// Secondary status of problem
1214     int secondaryStatus_;
1215     /// length of names (0 means no names)
1216     int lengthNames_;
1217     /// Number of threads (not very operational)
1218     int numberThreads_;
1219     /** For advanced options
1220         See get and set for meaning
1221     */
1222     unsigned int specialOptions_;
1223     /// Message handler
1224     CoinMessageHandler * handler_;
1225     /// Flag to say if default handler (so delete)
1226     bool defaultHandler_;
1227     /// Thread specific random number generator
1228     CoinThreadRandom randomNumberGenerator_;
1229     /// Event handler
1230     ClpEventHandler * eventHandler_;
1231#ifndef CLP_NO_STD
1232     /// Row names
1233     std::vector<std::string> rowNames_;
1234     /// Column names
1235     std::vector<std::string> columnNames_;
1236#endif
1237     /// Messages
1238     CoinMessages messages_;
1239     /// Coin messages
1240     CoinMessages coinMessages_;
1241     /// Maximum number of columns in model
1242     int maximumColumns_;
1243     /// Maximum number of rows in model
1244     int maximumRows_;
1245     /// Maximum number of columns (internal arrays) in model
1246     int maximumInternalColumns_;
1247     /// Maximum number of rows (internal arrays) in model
1248     int maximumInternalRows_;
1249     /// Base packed matrix
1250     CoinPackedMatrix baseMatrix_;
1251     /// Base row copy
1252     CoinPackedMatrix baseRowCopy_;
1253     /// Saved row scale factors for matrix
1254     double * savedRowScale_;
1255     /// Saved column scale factors
1256     double * savedColumnScale_;
1257#ifndef CLP_NO_STD
1258     /// Array of string parameters
1259     std::string strParam_[ClpLastStrParam];
1260#endif
1261     //@}
1262};
1263/** This is a tiny class where data can be saved round calls.
1264 */
1265class ClpDataSave {
1266
1267public:
1268     /**@name Constructors and destructor
1269      */
1270     //@{
1271     /// Default constructor
1272     ClpDataSave (  );
1273
1274     /// Copy constructor.
1275     ClpDataSave(const ClpDataSave &);
1276     /// Assignment operator. This copies the data
1277     ClpDataSave & operator=(const ClpDataSave & rhs);
1278     /// Destructor
1279     ~ClpDataSave (  );
1280
1281     //@}
1282
1283////////////////// data //////////////////
1284public:
1285
1286     /**@name data - with same names as in other classes*/
1287     //@{
1288     double dualBound_;
1289     double infeasibilityCost_;
1290     double pivotTolerance_;
1291     double zeroFactorizationTolerance_;
1292     double zeroSimplexTolerance_;
1293     double acceptablePivot_;
1294     double objectiveScale_;
1295     int sparseThreshold_;
1296     int perturbation_;
1297     int forceFactorization_;
1298     int scalingFlag_;
1299     unsigned int specialOptions_;
1300     //@}
1301};
1302
1303#endif
Note: See TracBrowser for help on using the repository browser.