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

Last change on this file since 1665 was 1665, checked in by lou, 9 years ago

Add EPL license notice in src.

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