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

Last change on this file since 1924 was 1924, checked in by forrest, 7 years ago

changes for miqp, parameters and presolve

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 48.6 KB
Line 
1/* $Id: ClpModel.hpp 1924 2013-03-19 13:01:05Z forrest $ */
2// Copyright (C) 2002, International Business Machines
3// Corporation and others.  All Rights Reserved.
4// This code is licensed under the terms of the Eclipse Public License (EPL).
5
6#ifndef ClpModel_H
7#define ClpModel_H
8
9#include "ClpConfig.h"
10
11#include <iostream>
12#include <cassert>
13#include <cmath>
14#include <vector>
15#include <string>
16//#ifndef COIN_USE_CLP
17//#define COIN_USE_CLP
18//#endif
19#include "ClpPackedMatrix.hpp"
20#include "CoinMessageHandler.hpp"
21#include "CoinHelperFunctions.hpp"
22#include "CoinTypes.hpp"
23#include "CoinFinite.hpp"
24#include "ClpParameters.hpp"
25#include "ClpObjective.hpp"
26class ClpEventHandler;
27/** This is the base class for Linear and quadratic Models
28    This knows nothing about the algorithm, but it seems to
29    have a reasonable amount of information
30
31    I would welcome suggestions for what should be in this and
32    how it relates to OsiSolverInterface.  Some methods look
33    very similar.
34
35*/
36class CoinBuild;
37class CoinModel;
38class ClpModel {
39
40public:
41
42     /**@name Constructors and destructor
43        Note - copy methods copy ALL data so can chew up memory
44        until other copy is freed
45      */
46     //@{
47     /// Default constructor
48     ClpModel (bool emptyMessages = false  );
49
50     /** Copy constructor. May scale depending on mode
51         -1 leave mode as is
52         0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 auto-but-as-initialSolve-in-bab
53     */
54     ClpModel(const ClpModel & rhs, int scalingMode = -1);
55     /// Assignment operator. This copies the data
56     ClpModel & operator=(const ClpModel & rhs);
57     /** Subproblem constructor.  A subset of whole model is created from the
58         row and column lists given.  The new order is given by list order and
59         duplicates are allowed.  Name and integer information can be dropped
60     */
61     ClpModel (const ClpModel * wholeModel,
62               int numberRows, const int * whichRows,
63               int numberColumns, const int * whichColumns,
64               bool dropNames = true, bool dropIntegers = true);
65     /// Destructor
66     ~ClpModel (  );
67     //@}
68
69     /**@name Load model - loads some stuff and initializes others */
70     //@{
71     /** Loads a problem (the constraints on the
72         rows are given by lower and upper bounds). If a pointer is 0 then the
73         following values are the default:
74         <ul>
75           <li> <code>colub</code>: all columns have upper bound infinity
76           <li> <code>collb</code>: all columns have lower bound 0
77           <li> <code>rowub</code>: all rows have upper bound infinity
78           <li> <code>rowlb</code>: all rows have lower bound -infinity
79       <li> <code>obj</code>: all variables have 0 objective coefficient
80         </ul>
81     */
82     void loadProblem (  const ClpMatrixBase& matrix,
83                         const double* collb, const double* colub,
84                         const double* obj,
85                         const double* rowlb, const double* rowub,
86                         const double * rowObjective = NULL);
87     void loadProblem (  const CoinPackedMatrix& matrix,
88                         const double* collb, const double* colub,
89                         const double* obj,
90                         const double* rowlb, const double* rowub,
91                         const double * rowObjective = NULL);
92
93     /** Just like the other loadProblem() method except that the matrix is
94       given in a standard column major ordered format (without gaps). */
95     void loadProblem (  const int numcols, const int numrows,
96                         const CoinBigIndex* start, const int* index,
97                         const double* value,
98                         const double* collb, const double* colub,
99                         const double* obj,
100                         const double* rowlb, const double* rowub,
101                         const double * rowObjective = NULL);
102     /** This loads a model from a coinModel object - returns number of errors.
103
104         modelObject not const as may be changed as part of process
105         If tryPlusMinusOne then will try adding as +-1 matrix
106     */
107     int loadProblem (  CoinModel & modelObject, bool tryPlusMinusOne = false);
108     /// This one is for after presolve to save memory
109     void loadProblem (  const int numcols, const int numrows,
110                         const CoinBigIndex* start, const int* index,
111                         const double* value, const int * length,
112                         const double* collb, const double* colub,
113                         const double* obj,
114                         const double* rowlb, const double* rowub,
115                         const double * rowObjective = NULL);
116     /** Load up quadratic objective.  This is stored as a CoinPackedMatrix */
117     void loadQuadraticObjective(const int numberColumns,
118                                 const CoinBigIndex * start,
119                                 const int * column, const double * element);
120     void loadQuadraticObjective (  const CoinPackedMatrix& matrix);
121     /// Get rid of quadratic objective
122     void deleteQuadraticObjective();
123     /// This just loads up a row objective
124     void setRowObjective(const double * rowObjective);
125     /// Read an mps file from the given filename
126     int readMps(const char *filename,
127                 bool keepNames = false,
128                 bool ignoreErrors = false);
129     /// Read GMPL files from the given filenames
130     int readGMPL(const char *filename, const char * dataName,
131                  bool keepNames = false);
132     /// Copy in integer informations
133     void copyInIntegerInformation(const char * information);
134     /// Drop integer informations
135     void deleteIntegerInformation();
136     /** Set the index-th variable to be a continuous variable */
137     void setContinuous(int index);
138     /** Set the index-th variable to be an integer variable */
139     void setInteger(int index);
140     /** Return true if the index-th variable is an integer variable */
141     bool isInteger(int index) const;
142     /// Resizes rim part of model
143     void resize (int newNumberRows, int newNumberColumns);
144     /// Deletes rows
145     void deleteRows(int number, const int * which);
146     /// Add one row
147     void addRow(int numberInRow, const int * columns,
148                 const double * elements, double rowLower = -COIN_DBL_MAX,
149                 double rowUpper = COIN_DBL_MAX);
150     /// Add rows
151     void addRows(int number, const double * rowLower,
152                  const double * rowUpper,
153                  const CoinBigIndex * rowStarts, const int * columns,
154                  const double * elements);
155     /// Add rows
156     void addRows(int number, const double * rowLower,
157                  const double * rowUpper,
158                  const CoinBigIndex * rowStarts, const int * rowLengths,
159                  const int * columns,
160                  const double * elements);
161#ifndef CLP_NO_VECTOR
162     void addRows(int number, const double * rowLower,
163                  const double * rowUpper,
164                  const CoinPackedVectorBase * const * rows);
165#endif
166     /** Add rows from a build object.
167         If tryPlusMinusOne then will try adding as +-1 matrix
168         if no matrix exists.
169         Returns number of errors e.g. duplicates
170     */
171     int addRows(const CoinBuild & buildObject, bool tryPlusMinusOne = false,
172                 bool checkDuplicates = true);
173     /** Add rows from a model object.  returns
174         -1 if object in bad state (i.e. has column information)
175         otherwise number of errors.
176
177         modelObject non const as can be regularized as part of build
178         If tryPlusMinusOne then will try adding as +-1 matrix
179         if no matrix exists.
180     */
181     int addRows(CoinModel & modelObject, bool tryPlusMinusOne = false,
182                 bool checkDuplicates = true);
183
184     /// Deletes columns
185     void deleteColumns(int number, const int * which);
186     /// Deletes rows AND columns (keeps old sizes)
187     void deleteRowsAndColumns(int numberRows, const int * whichRows,
188                               int numberColumns, const int * whichColumns);
189     /// Add one column
190     void addColumn(int numberInColumn,
191                    const int * rows,
192                    const double * elements,
193                    double columnLower = 0.0,
194                    double  columnUpper = COIN_DBL_MAX,
195                    double  objective = 0.0);
196     /// Add columns
197     void addColumns(int number, const double * columnLower,
198                     const double * columnUpper,
199                     const double * objective,
200                     const CoinBigIndex * columnStarts, const int * rows,
201                     const double * elements);
202     void addColumns(int number, const double * columnLower,
203                     const double * columnUpper,
204                     const double * objective,
205                     const CoinBigIndex * columnStarts, const int * columnLengths,
206                     const int * rows,
207                     const double * elements);
208#ifndef CLP_NO_VECTOR
209     void addColumns(int number, const double * columnLower,
210                     const double * columnUpper,
211                     const double * objective,
212                     const CoinPackedVectorBase * const * columns);
213#endif
214     /** Add columns from a build object
215         If tryPlusMinusOne then will try adding as +-1 matrix
216         if no matrix exists.
217         Returns number of errors e.g. duplicates
218     */
219     int addColumns(const CoinBuild & buildObject, bool tryPlusMinusOne = false,
220                    bool checkDuplicates = true);
221     /** Add columns from a model object.  returns
222         -1 if object in bad state (i.e. has row information)
223         otherwise number of errors
224         modelObject non const as can be regularized as part of build
225         If tryPlusMinusOne then will try adding as +-1 matrix
226         if no matrix exists.
227     */
228     int addColumns(CoinModel & modelObject, bool tryPlusMinusOne = false,
229                    bool checkDuplicates = true);
230     /// Modify one element of a matrix
231     inline void modifyCoefficient(int row, int column, double newElement,
232                                   bool keepZero = false) {
233          matrix_->modifyCoefficient(row, column, newElement, keepZero);
234     }
235     /** Change row lower bounds */
236     void chgRowLower(const double * rowLower);
237     /** Change row upper bounds */
238     void chgRowUpper(const double * rowUpper);
239     /** Change column lower bounds */
240     void chgColumnLower(const double * columnLower);
241     /** Change column upper bounds */
242     void chgColumnUpper(const double * columnUpper);
243     /** Change objective coefficients */
244     void chgObjCoefficients(const double * objIn);
245     /** Borrow model.  This is so we don't have to copy large amounts
246         of data around.  It assumes a derived class wants to overwrite
247         an empty model with a real one - while it does an algorithm */
248     void borrowModel(ClpModel & otherModel);
249     /** Return model - nulls all arrays so can be deleted safely
250         also updates any scalars */
251     void returnModel(ClpModel & otherModel);
252
253     /// Create empty ClpPackedMatrix
254     void createEmptyMatrix();
255     /** Really clean up matrix (if ClpPackedMatrix).
256         a) eliminate all duplicate AND small elements in matrix
257         b) remove all gaps and set extraGap_ and extraMajor_ to 0.0
258         c) reallocate arrays and make max lengths equal to lengths
259         d) orders elements
260         returns number of elements eliminated or -1 if not ClpPackedMatrix
261     */
262     int cleanMatrix(double threshold = 1.0e-20);
263     /// Copy contents - resizing if necessary - otherwise re-use memory
264     void copy(const ClpMatrixBase * from, ClpMatrixBase * & to);
265#ifndef CLP_NO_STD
266     /// Drops names - makes lengthnames 0 and names empty
267     void dropNames();
268     /// Copies in names
269     void copyNames(std::vector<std::string> & rowNames,
270                    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() 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     /// Return handler
843     inline CoinMessageHandler * messageHandler() const       {
844          return handler_;
845     }
846     /// Return messages
847     inline CoinMessages messages() const                     {
848          return messages_;
849     }
850     /// Return pointer to messages
851     inline CoinMessages * messagesPointer()                  {
852          return & messages_;
853     }
854     /// Return Coin messages
855     inline CoinMessages coinMessages() const                  {
856          return coinMessages_;
857     }
858     /// Return pointer to Coin messages
859     inline CoinMessages * coinMessagesPointer()                  {
860          return & coinMessages_;
861     }
862     /** Amount of print out:
863         0 - none
864         1 - just final
865         2 - just factorizations
866         3 - as 2 plus a bit more
867         4 - verbose
868         above that 8,16,32 etc just for selective debug
869     */
870     inline void setLogLevel(int value)    {
871          handler_->setLogLevel(value);
872     }
873     inline int logLevel() const           {
874          return handler_->logLevel();
875     }
876     /// Return true if default handler
877     inline bool defaultHandler() const {
878          return defaultHandler_;
879     }
880     /// Pass in Event handler (cloned and deleted at end)
881     void passInEventHandler(const ClpEventHandler * eventHandler);
882     /// Event handler
883     inline ClpEventHandler * eventHandler() const {
884          return eventHandler_;
885     }
886     /// Thread specific random number generator
887     inline CoinThreadRandom * randomNumberGenerator() {
888          return &randomNumberGenerator_;
889     }
890     /// Thread specific random number generator
891     inline CoinThreadRandom & mutableRandomNumberGenerator() {
892          return randomNumberGenerator_;
893     }
894     /// Set seed for thread specific random number generator
895     inline void setRandomSeed(int value) {
896          randomNumberGenerator_.setSeed(value);
897     }
898     /// length of names (0 means no names0
899     inline int lengthNames() const {
900          return lengthNames_;
901     }
902#ifndef CLP_NO_STD
903     /// length of names (0 means no names0
904     inline void setLengthNames(int value) {
905          lengthNames_ = value;
906     }
907     /// Row names
908     inline const std::vector<std::string> * rowNames() const {
909          return &rowNames_;
910     }
911     inline const std::string& rowName(int iRow) const {
912          return rowNames_[iRow];
913     }
914     /// Return name or Rnnnnnnn
915     std::string getRowName(int iRow) const;
916     /// Column names
917     inline const std::vector<std::string> * columnNames() const {
918          return &columnNames_;
919     }
920     inline const std::string& columnName(int iColumn) const {
921          return columnNames_[iColumn];
922     }
923     /// Return name or Cnnnnnnn
924     std::string getColumnName(int iColumn) const;
925#endif
926     /// Objective methods
927     inline ClpObjective * objectiveAsObject() const {
928          return objective_;
929     }
930     void setObjective(ClpObjective * objective);
931     inline void setObjectivePointer(ClpObjective * newobjective) {
932          objective_ = newobjective;
933     }
934     /** Solve a problem with no elements - return status and
935         dual and primal infeasibilites */
936     int emptyProblem(int * infeasNumber = NULL, double * infeasSum = NULL, bool printMessage = true);
937
938     //@}
939
940     /**@name Matrix times vector methods
941        They can be faster if scalar is +- 1
942        These are covers so user need not worry about scaling
943        Also for simplex I am not using basic/non-basic split */
944     //@{
945     /** Return <code>y + A * x * scalar</code> in <code>y</code>.
946         @pre <code>x</code> must be of size <code>numColumns()</code>
947         @pre <code>y</code> must be of size <code>numRows()</code> */
948     void times(double scalar,
949                const double * x, double * y) const;
950     /** Return <code>y + x * scalar * A</code> in <code>y</code>.
951         @pre <code>x</code> must be of size <code>numRows()</code>
952         @pre <code>y</code> must be of size <code>numColumns()</code> */
953     void transposeTimes(double scalar,
954                         const double * x, double * y) const ;
955     //@}
956
957
958     //---------------------------------------------------------------------------
959     /**@name Parameter set/get methods
960
961        The set methods return true if the parameter was set to the given value,
962        false otherwise. There can be various reasons for failure: the given
963        parameter is not applicable for the solver (e.g., refactorization
964        frequency for the volume algorithm), the parameter is not yet implemented
965        for the solver or simply the value of the parameter is out of the range
966        the solver accepts. If a parameter setting call returns false check the
967        details of your solver.
968
969        The get methods return true if the given parameter is applicable for the
970        solver and is implemented. In this case the value of the parameter is
971        returned in the second argument. Otherwise they return false.
972
973        ** once it has been decided where solver sits this may be redone
974     */
975     //@{
976     /// Set an integer parameter
977     bool setIntParam(ClpIntParam key, int value) ;
978     /// Set an double parameter
979     bool setDblParam(ClpDblParam key, double value) ;
980#ifndef CLP_NO_STD
981     /// Set an string parameter
982     bool setStrParam(ClpStrParam key, const std::string & value);
983#endif
984     // Get an integer parameter
985     inline bool getIntParam(ClpIntParam key, int& value) const {
986          if (key < ClpLastIntParam) {
987               value = intParam_[key];
988               return true;
989          } else {
990               return false;
991          }
992     }
993     // Get an double parameter
994     inline bool getDblParam(ClpDblParam key, double& value) const {
995          if (key < ClpLastDblParam) {
996               value = dblParam_[key];
997               return true;
998          } else {
999               return false;
1000          }
1001     }
1002#ifndef CLP_NO_STD
1003     // Get a string parameter
1004     inline bool getStrParam(ClpStrParam key, std::string& value) const {
1005          if (key < ClpLastStrParam) {
1006               value = strParam_[key];
1007               return true;
1008          } else {
1009               return false;
1010          }
1011     }
1012#endif
1013     /// Create C++ lines to get to current state
1014     void generateCpp( FILE * fp);
1015     /** For advanced options
1016         1 - Don't keep changing infeasibility weight
1017         2 - Keep nonLinearCost round solves
1018         4 - Force outgoing variables to exact bound (primal)
1019         8 - Safe to use dense initial factorization
1020         16 -Just use basic variables for operation if column generation
1021         32 -Create ray even in BAB
1022         64 -Treat problem as feasible until last minute (i.e. minimize infeasibilities)
1023         128 - Switch off all matrix sanity checks
1024         256 - No row copy
1025         512 - If not in values pass, solution guaranteed, skip as much as possible
1026         1024 - In branch and bound
1027         2048 - Don't bother to re-factorize if < 20 iterations
1028         4096 - Skip some optimality checks
1029         8192 - Do Primal when cleaning up primal
1030         16384 - In fast dual (so we can switch off things)
1031         32768 - called from Osi
1032         65536 - keep arrays around as much as possible (also use maximumR/C)
1033         131072 - transposeTimes is -1.0 and can skip basic and fixed
1034         262144 - extra copy of scaled matrix
1035         524288 - Clp fast dual
1036         1048576 - don't need to finish dual (can return 3)
1037         2097152 - zero costs!
1038         NOTE - many applications can call Clp but there may be some short cuts
1039                which are taken which are not guaranteed safe from all applications.
1040                Vetted applications will have a bit set and the code may test this
1041                At present I expect a few such applications - if too many I will
1042                have to re-think.  It is up to application owner to change the code
1043                if she/he needs these short cuts.  I will not debug unless in Coin
1044                repository.  See COIN_CLP_VETTED comments.
1045         0x01000000 is Cbc (and in branch and bound)
1046         0x02000000 is in a different branch and bound
1047     */
1048     inline unsigned int specialOptions() const {
1049          return specialOptions_;
1050     }
1051     void setSpecialOptions(unsigned int value);
1052#define COIN_CBC_USING_CLP 0x01000000
1053     inline bool inCbcBranchAndBound() const {
1054          return (specialOptions_ & COIN_CBC_USING_CLP) != 0;
1055     }
1056     //@}
1057
1058     /**@name private or protected methods */
1059     //@{
1060protected:
1061     /// Does most of deletion (0 = all, 1 = most)
1062     void gutsOfDelete(int type);
1063     /** Does most of copying
1064         If trueCopy 0 then just points to arrays
1065         If -1 leaves as much as possible */
1066     void gutsOfCopy(const ClpModel & rhs, int trueCopy = 1);
1067     /// gets lower and upper bounds on rows
1068     void getRowBound(int iRow, double& lower, double& upper) const;
1069     /// puts in format I like - 4 array matrix - may make row copy
1070     void gutsOfLoadModel ( int numberRows, int numberColumns,
1071                            const double* collb, const double* colub,
1072                            const double* obj,
1073                            const double* rowlb, const double* rowub,
1074                            const double * rowObjective = NULL);
1075     /// Does much of scaling
1076     void gutsOfScaling();
1077     /// Objective value - always minimize
1078     inline double rawObjectiveValue() const {
1079          return objectiveValue_;
1080     }
1081     /// If we are using maximumRows_ and Columns_
1082     inline bool permanentArrays() const {
1083          return (specialOptions_ & 65536) != 0;
1084     }
1085     /// Start using maximumRows_ and Columns_
1086     void startPermanentArrays();
1087     /// Stop using maximumRows_ and Columns_
1088     void stopPermanentArrays();
1089     /// Create row names as char **
1090     const char * const * rowNamesAsChar() const;
1091     /// Create column names as char **
1092     const char * const * columnNamesAsChar() const;
1093     /// Delete char * version of names
1094     void deleteNamesAsChar(const char * const * names, int number) const;
1095     /// On stopped - sets secondary status
1096     void onStopped();
1097     //@}
1098
1099
1100////////////////// data //////////////////
1101protected:
1102
1103     /**@name data */
1104     //@{
1105     /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
1106     double optimizationDirection_;
1107     /// Array of double parameters
1108     double dblParam_[ClpLastDblParam];
1109     /// Objective value
1110     double objectiveValue_;
1111     /// Small element value
1112     double smallElement_;
1113     /// Scaling of objective
1114     double objectiveScale_;
1115     /// Scaling of rhs and bounds
1116     double rhsScale_;
1117     /// Number of rows
1118     int numberRows_;
1119     /// Number of columns
1120     int numberColumns_;
1121     /// Row activities
1122     double * rowActivity_;
1123     /// Column activities
1124     double * columnActivity_;
1125     /// Duals
1126     double * dual_;
1127     /// Reduced costs
1128     double * reducedCost_;
1129     /// Row lower
1130     double* rowLower_;
1131     /// Row upper
1132     double* rowUpper_;
1133     /// Objective
1134     ClpObjective * objective_;
1135     /// Row Objective (? sign)  - may be NULL
1136     double * rowObjective_;
1137     /// Column Lower
1138     double * columnLower_;
1139     /// Column Upper
1140     double * columnUpper_;
1141     /// Packed matrix
1142     ClpMatrixBase * matrix_;
1143     /// Row copy if wanted
1144     ClpMatrixBase * rowCopy_;
1145     /// Scaled packed matrix
1146     ClpPackedMatrix * scaledMatrix_;
1147     /// Infeasible/unbounded ray
1148     double * ray_;
1149     /// Row scale factors for matrix
1150     double * rowScale_;
1151     /// Column scale factors
1152     double * columnScale_;
1153     /// Inverse row scale factors for matrix (end of rowScale_)
1154     double * inverseRowScale_;
1155     /// Inverse column scale factors for matrix (end of columnScale_)
1156     double * inverseColumnScale_;
1157     /** Scale flag, 0 none, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic,
1158         5 geometric on rows */
1159     int scalingFlag_;
1160     /** Status (i.e. basis) Region.  I know that not all algorithms need a status
1161         array, but it made sense for things like crossover and put
1162         all permanent stuff in one place.  No assumption is made
1163         about what is in status array (although it might be good to reserve
1164         bottom 3 bits (i.e. 0-7 numeric) for classic status).  This
1165         is number of columns + number of rows long (in that order).
1166     */
1167     unsigned char * status_;
1168     /// Integer information
1169     char * integerType_;
1170     /// User pointer for whatever reason
1171     void * userPointer_;
1172     /// Trusted user pointer e.g. for heuristics
1173     ClpTrustedData * trustedUserPointer_;
1174     /// Array of integer parameters
1175     int intParam_[ClpLastIntParam];
1176     /// Number of iterations
1177     int numberIterations_;
1178     /** Solve type - 1 simplex, 2 simplex interface, 3 Interior.*/
1179     int solveType_;
1180     /** Whats changed since last solve.  This is a work in progress
1181         It is designed so careful people can make go faster.
1182         It is only used when startFinishOptions used in dual or primal.
1183         Bit 1 - number of rows/columns has not changed (so work arrays valid)
1184             2 - matrix has not changed
1185             4 - if matrix has changed only by adding rows
1186             8 - if matrix has changed only by adding columns
1187            16 - row lbs not changed
1188            32 - row ubs not changed
1189            64 - column objective not changed
1190           128 - column lbs not changed
1191           256 - column ubs not changed
1192       512 - basis not changed (up to user to set this to 0)
1193             top bits may be used internally
1194       shift by 65336 is 3 all same, 1 all except col bounds
1195     */
1196#define ROW_COLUMN_COUNTS_SAME 1
1197#define MATRIX_SAME 2
1198#define MATRIX_JUST_ROWS_ADDED 4
1199#define MATRIX_JUST_COLUMNS_ADDED 8
1200#define ROW_LOWER_SAME 16
1201#define ROW_UPPER_SAME 32
1202#define OBJECTIVE_SAME 64
1203#define COLUMN_LOWER_SAME 128
1204#define COLUMN_UPPER_SAME 256
1205#define BASIS_SAME 512
1206#define ALL_SAME 65339
1207#define ALL_SAME_EXCEPT_COLUMN_BOUNDS 65337
1208     unsigned int whatsChanged_;
1209     /// Status of problem
1210     int problemStatus_;
1211     /// Secondary status of problem
1212     int secondaryStatus_;
1213     /// length of names (0 means no names)
1214     int lengthNames_;
1215     /// Number of threads (not very operational)
1216     int numberThreads_;
1217     /** For advanced options
1218         See get and set for meaning
1219     */
1220     unsigned int specialOptions_;
1221     /// Message handler
1222     CoinMessageHandler * handler_;
1223     /// Flag to say if default handler (so delete)
1224     bool defaultHandler_;
1225     /// Thread specific random number generator
1226     CoinThreadRandom randomNumberGenerator_;
1227     /// Event handler
1228     ClpEventHandler * eventHandler_;
1229#ifndef CLP_NO_STD
1230     /// Row names
1231     std::vector<std::string> rowNames_;
1232     /// Column names
1233     std::vector<std::string> columnNames_;
1234#endif
1235     /// Messages
1236     CoinMessages messages_;
1237     /// Coin messages
1238     CoinMessages coinMessages_;
1239     /// Maximum number of columns in model
1240     int maximumColumns_;
1241     /// Maximum number of rows in model
1242     int maximumRows_;
1243     /// Maximum number of columns (internal arrays) in model
1244     int maximumInternalColumns_;
1245     /// Maximum number of rows (internal arrays) in model
1246     int maximumInternalRows_;
1247     /// Base packed matrix
1248     CoinPackedMatrix baseMatrix_;
1249     /// Base row copy
1250     CoinPackedMatrix baseRowCopy_;
1251     /// Saved row scale factors for matrix
1252     double * savedRowScale_;
1253     /// Saved column scale factors
1254     double * savedColumnScale_;
1255#ifndef CLP_NO_STD
1256     /// Array of string parameters
1257     std::string strParam_[ClpLastStrParam];
1258#endif
1259     //@}
1260};
1261/** This is a tiny class where data can be saved round calls.
1262 */
1263class ClpDataSave {
1264
1265public:
1266     /**@name Constructors and destructor
1267      */
1268     //@{
1269     /// Default constructor
1270     ClpDataSave (  );
1271
1272     /// Copy constructor.
1273     ClpDataSave(const ClpDataSave &);
1274     /// Assignment operator. This copies the data
1275     ClpDataSave & operator=(const ClpDataSave & rhs);
1276     /// Destructor
1277     ~ClpDataSave (  );
1278
1279     //@}
1280
1281////////////////// data //////////////////
1282public:
1283
1284     /**@name data - with same names as in other classes*/
1285     //@{
1286     double dualBound_;
1287     double infeasibilityCost_;
1288     double pivotTolerance_;
1289     double zeroFactorizationTolerance_;
1290     double zeroSimplexTolerance_;
1291     double acceptablePivot_;
1292     double objectiveScale_;
1293     int sparseThreshold_;
1294     int perturbation_;
1295     int forceFactorization_;
1296     int scalingFlag_;
1297     unsigned int specialOptions_;
1298     //@}
1299};
1300
1301#endif
Note: See TracBrowser for help on using the repository browser.