source: branches/devel-1/ClpModel.cpp @ 17

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

Synchronizing

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 22.6 KB
Line 
1// Copyright (C) 2002, International Business Machines
2// Corporation and others.  All Rights Reserved.
3#if defined(_MSC_VER)
4// Turn off compiler warning about long names
5#  pragma warning(disable:4786)
6#endif
7
8#include <math.h>
9
10#include "CoinHelperFunctions.hpp"
11#include "ClpModel.hpp"
12#include "ClpPackedMatrix.hpp"
13#include "OsiIndexedVector.hpp"
14#include "OsiMpsReader.hpp"
15#include "ClpMessage.hpp"
16#include <cassert>
17#include <cfloat>
18
19#include <string>
20#include <stdio.h>
21#include <iostream>
22#include  <time.h>
23#include <sys/times.h>
24#include <sys/resource.h>
25#include <unistd.h>
26// This returns a non const array filled with input from scalar
27// or actual array
28template <class T> inline T*
29copyOfArray( const T * array, const int size, T value)
30{
31  T * arrayNew = new T[size];
32  if (array) 
33    CoinDisjointCopyN(array,size,arrayNew);
34  else
35    CoinFillN ( arrayNew, size,value);
36  return arrayNew;
37}
38
39// This returns a non const array filled with actual array (or NULL)
40template <class T> inline T*
41copyOfArray( const T * array, const int size)
42{
43  if (array) {
44    T * arrayNew = new T[size];
45    CoinDisjointCopyN(array,size,arrayNew);
46    return arrayNew;
47  } else {
48    return NULL;
49  }
50}
51static double cpuTime()
52{
53  double cpu_temp;
54#if defined(_MSC_VER)
55  unsigned int ticksnow;        /* clock_t is same as int */
56 
57  ticksnow = (unsigned int)clock();
58 
59  cpu_temp = (double)((double)ticksnow/CLOCKS_PER_SEC);
60#else
61  struct rusage usage;
62  getrusage(RUSAGE_SELF,&usage);
63  cpu_temp = usage.ru_utime.tv_sec;
64  cpu_temp += 1.0e-6*((double) usage.ru_utime.tv_usec);
65#endif
66  return cpu_temp;
67}
68//#############################################################################
69
70ClpModel::ClpModel () :
71
72  optimizationDirection_(1),
73  numberRows_(0),
74  numberColumns_(0),
75  rowActivity_(NULL),
76  columnActivity_(NULL),
77  dual_(NULL),
78  reducedCost_(NULL),
79  rowLower_(NULL),
80  rowUpper_(NULL),
81  objective_(NULL),
82  rowObjective_(NULL),
83  columnLower_(NULL),
84  columnUpper_(NULL),
85  matrix_(NULL),
86  rowCopy_(NULL),
87  ray_(NULL),
88  objectiveValue_(0.0),
89  numberIterations_(0),
90  problemStatus_(-1),
91  maximumIterations_(1000000000),
92  defaultHandler_(true),
93  lengthNames_(0),
94  rowNames_(),
95  columnNames_(),
96  integerType_(NULL)
97{
98  intParam_[OsiMaxNumIteration] = 9999999;
99  intParam_[OsiMaxNumIterationHotStart] = 9999999;
100
101  dblParam_[OsiDualObjectiveLimit] = DBL_MAX;
102  dblParam_[OsiPrimalObjectiveLimit] = DBL_MAX;
103  dblParam_[OsiDualTolerance] = 1e-7;
104  dblParam_[OsiPrimalTolerance] = 1e-7;
105  dblParam_[OsiObjOffset] = 0.0;
106
107  strParam_[OsiProbName] = "OsiDefaultName";
108  handler_ = new OsiMessageHandler();
109  handler_->setLogLevel(2);
110  messages_ = ClpMessage();
111}
112
113//-----------------------------------------------------------------------------
114
115ClpModel::~ClpModel ()
116{
117  if (defaultHandler_) {
118    delete handler_;
119    handler_ = NULL;
120  }
121  gutsOfDelete();
122}
123void ClpModel::gutsOfDelete()
124{
125  delete [] rowActivity_;
126  rowActivity_=NULL;
127  delete [] columnActivity_;
128  columnActivity_=NULL;
129  delete [] dual_;
130  dual_=NULL;
131  delete [] reducedCost_;
132  reducedCost_=NULL;
133  delete [] rowLower_;
134  delete [] rowUpper_;
135  delete [] rowObjective_;
136  rowLower_=NULL;
137  rowUpper_=NULL;
138  rowObjective_=NULL;
139  delete [] columnLower_;
140  delete [] columnUpper_;
141  delete [] objective_;
142  columnLower_=NULL;
143  columnUpper_=NULL;
144  objective_=NULL;
145  delete matrix_;
146  matrix_=NULL;
147  delete rowCopy_;
148  rowCopy_=NULL;
149  delete [] ray_;
150  ray_ = NULL;
151  delete [] integerType_;
152  integerType_ = NULL;
153}
154//#############################################################################
155void ClpModel::setPrimalTolerance( double value) 
156{
157  if (value>0.0&&value<1.0e10)
158    dblParam_[OsiPrimalTolerance]=value;
159}
160void ClpModel::setDualTolerance( double value) 
161{
162  if (value>0.0&&value<1.0e10)
163    dblParam_[OsiDualTolerance]=value;
164}
165void ClpModel::setOptimizationDirection( int value) 
166{
167  if (value>=-1&&value<=1)
168    optimizationDirection_=value;
169}
170void
171ClpModel::gutsOfLoadModel (int numberRows, int numberColumns, 
172                     const double* collb, const double* colub,   
173                     const double* obj,
174                     const double* rowlb, const double* rowub,
175                                const double * rowObjective)
176{
177  gutsOfDelete();
178  numberRows_=numberRows;
179  numberColumns_=numberColumns;
180  rowActivity_=new double[numberRows_];
181  columnActivity_=new double[numberColumns_];
182  dual_=new double[numberRows_];
183  reducedCost_=new double[numberColumns_];
184
185  CoinFillN(dual_,numberRows_,0.0);
186  CoinFillN(reducedCost_,numberColumns_,0.0);
187  int iRow,iColumn;
188
189  rowLower_=copyOfArray(rowlb,numberRows_,-DBL_MAX);
190  rowUpper_=copyOfArray(rowub,numberRows_,DBL_MAX);
191  objective_=copyOfArray(obj,numberColumns_,0.0);
192  rowObjective_=copyOfArray(rowObjective,numberRows_);
193  columnLower_=copyOfArray(collb,numberColumns_,0.0);
194  columnUpper_=copyOfArray(colub,numberColumns_,DBL_MAX);
195  // set default solution
196  for (iRow=0;iRow<numberRows_;iRow++) {
197    if (rowLower_[iRow]>0.0) {
198      rowActivity_[iRow]=rowLower_[iRow];
199    } else if (rowUpper_[iRow]<0.0) {
200      rowActivity_[iRow]=rowUpper_[iRow];
201    } else {
202      rowActivity_[iRow]=0.0;
203    }
204  }
205  for (iColumn=0;iColumn<numberColumns_;iColumn++) {
206    if (columnLower_[iColumn]>0.0) {
207      columnActivity_[iColumn]=columnLower_[iColumn];
208    } else if (columnUpper_[iColumn]<0.0) {
209      columnActivity_[iColumn]=columnUpper_[iColumn];
210    } else {
211      columnActivity_[iColumn]=0.0;
212    }
213  }
214}
215void
216ClpModel::loadProblem (  const ClpMatrixBase& matrix,
217                     const double* collb, const double* colub,   
218                     const double* obj,
219                     const double* rowlb, const double* rowub,
220                                const double * rowObjective)
221{
222  gutsOfLoadModel(matrix.getNumRows(),matrix.getNumCols(),
223                  collb, colub, obj, rowlb, rowub, rowObjective);
224  if (matrix.isColOrdered()) {
225    matrix_=matrix.clone();
226  } else {
227    // later may want to keep as unknown class
228    OsiPackedMatrix matrix2;
229    matrix2.reverseOrderedCopyOf(*matrix.getPackedMatrix());
230    matrix.releasePackedMatrix();
231    matrix_=new ClpPackedMatrix(matrix2);
232  }   
233}
234void
235ClpModel::loadProblem (  const OsiPackedMatrix& matrix,
236                     const double* collb, const double* colub,   
237                     const double* obj,
238                     const double* rowlb, const double* rowub,
239                                const double * rowObjective)
240{
241  gutsOfLoadModel(matrix.getNumRows(),matrix.getNumCols(),
242                  collb, colub, obj, rowlb, rowub, rowObjective);
243  if (matrix.isColOrdered()) {
244    matrix_=new ClpPackedMatrix(matrix);
245  } else {
246    OsiPackedMatrix matrix2;
247    matrix2.reverseOrderedCopyOf(matrix);
248    matrix_=new ClpPackedMatrix(matrix2);
249  }   
250}
251void
252ClpModel::loadProblem ( 
253                              const int numcols, const int numrows,
254                              const int* start, const int* index,
255                              const double* value,
256                              const double* collb, const double* colub,   
257                              const double* obj,
258                              const double* rowlb, const double* rowub,
259                              const double * rowObjective)
260{
261  gutsOfLoadModel(numrows, numcols,
262                  collb, colub, obj, rowlb, rowub, rowObjective);
263  OsiPackedMatrix matrix(true,numrows,numcols,start[numcols],
264                              value,index,start,NULL);
265  matrix_ = new ClpPackedMatrix(matrix);
266}
267void
268ClpModel::getRowBound(int iRow, double& lower, double& upper) const
269{
270  lower=-DBL_MAX;
271  upper=DBL_MAX;
272  if (rowUpper_)
273    upper=rowUpper_[iRow];
274  if (rowLower_)
275    lower=rowLower_[iRow];
276}
277//#############################################################################
278// Copy constructor.
279ClpModel::ClpModel(const ClpModel &rhs) :
280  optimizationDirection_(rhs.optimizationDirection_),
281  numberRows_(rhs.numberRows_),
282  numberColumns_(rhs.numberColumns_)
283{
284  gutsOfCopy(rhs);
285}
286// Assignment operator. This copies the data
287ClpModel & 
288ClpModel::operator=(const ClpModel & rhs)
289{
290  if (this != &rhs) {
291    if (defaultHandler_) {
292      delete handler_;
293      handler_ = NULL;
294    }
295    gutsOfDelete();
296    optimizationDirection_ = rhs.optimizationDirection_;
297    numberRows_ = rhs.numberRows_;
298    numberColumns_ = rhs.numberColumns_;
299    gutsOfCopy(rhs);
300  }
301  return *this;
302}
303// Does most of copying
304void 
305ClpModel::gutsOfCopy(const ClpModel & rhs, bool trueCopy)
306{
307  defaultHandler_ = rhs.defaultHandler_;
308  if (defaultHandler_) 
309    handler_ = new OsiMessageHandler(*rhs.handler_);
310   else 
311    handler_ = rhs.handler_;
312  messages_ = rhs.messages_;
313  intParam_[OsiMaxNumIteration] = rhs.intParam_[OsiMaxNumIteration];
314  intParam_[OsiMaxNumIterationHotStart] = 
315    rhs.intParam_[OsiMaxNumIterationHotStart];
316
317  dblParam_[OsiDualObjectiveLimit] = rhs.dblParam_[OsiDualObjectiveLimit];
318  dblParam_[OsiPrimalObjectiveLimit] = rhs.dblParam_[OsiPrimalObjectiveLimit];
319  dblParam_[OsiDualTolerance] = rhs.dblParam_[OsiDualTolerance];
320  dblParam_[OsiPrimalTolerance] = rhs.dblParam_[OsiPrimalTolerance];
321  dblParam_[OsiObjOffset] = rhs.dblParam_[OsiObjOffset];
322
323  strParam_[OsiProbName] = rhs.strParam_[OsiProbName];
324
325  objectiveValue_=rhs.objectiveValue_;
326  numberIterations_ = rhs.numberIterations_;
327  problemStatus_ = rhs.problemStatus_;
328  maximumIterations_ = rhs.maximumIterations_;
329  if (trueCopy) {
330    lengthNames_ = rhs.lengthNames_;
331    rowNames_ = rhs.rowNames_;
332    columnNames_ = rhs.columnNames_;
333    if (rhs.integerType_) {
334      integerType_ = new char[numberColumns_];
335      memcpy(integerType_,rhs.integerType_,numberColumns_*sizeof(char));
336    } else {
337      integerType_ = NULL;
338    }
339    if (rhs.rowActivity_) {
340      rowActivity_=new double[numberRows_];
341      columnActivity_=new double[numberColumns_];
342      dual_=new double[numberRows_];
343      reducedCost_=new double[numberColumns_];
344      CoinDisjointCopyN ( rhs.rowActivity_, numberRows_ ,
345                          rowActivity_);
346      CoinDisjointCopyN ( rhs.columnActivity_, numberColumns_ ,
347                          columnActivity_);
348      CoinDisjointCopyN ( rhs.dual_, numberRows_ , 
349                          dual_);
350      CoinDisjointCopyN ( rhs.reducedCost_, numberColumns_ ,
351                          reducedCost_);
352    } else {
353      rowActivity_=NULL;
354      columnActivity_=NULL;
355      dual_=NULL;
356      reducedCost_=NULL;
357    }
358    rowLower_ = copyOfArray ( rhs.rowLower_, numberRows_ );
359    rowUpper_ = copyOfArray ( rhs.rowUpper_, numberRows_ );
360    columnLower_ = copyOfArray ( rhs.columnLower_, numberColumns_ );
361    columnUpper_ = copyOfArray ( rhs.columnUpper_, numberColumns_ );
362    objective_ = copyOfArray ( rhs.objective_, numberColumns_ );
363    rowObjective_ = copyOfArray ( rhs.rowObjective_, numberRows_ );
364    ray_ = NULL;
365    if (problemStatus_==1)
366      ray_ = copyOfArray (rhs.ray_,numberRows_);
367    else if (problemStatus_==2)
368      ray_ = copyOfArray (rhs.ray_,numberColumns_);
369    if (rhs.rowCopy_) {
370      rowCopy_ = rhs.rowCopy_->clone();
371    } else {
372      rowCopy_=NULL;
373    }
374    matrix_=NULL;
375    if (rhs.matrix_) {
376      matrix_ = rhs.matrix_->clone();
377    }
378  } else {
379    rowActivity_ = rhs.rowActivity_;
380    columnActivity_ = rhs.columnActivity_;
381    dual_ = rhs.dual_;
382    reducedCost_ = rhs.reducedCost_;
383    rowLower_ = rhs.rowLower_;
384    rowUpper_ = rhs.rowUpper_;
385    objective_ = rhs.objective_;
386    rowObjective_ = rhs.rowObjective_;
387    columnLower_ = rhs.columnLower_;
388    columnUpper_ = rhs.columnUpper_;
389    matrix_ = rhs.matrix_;
390    rowCopy_ = rhs.rowCopy_;
391    ray_ = rhs.ray_;
392    lengthNames_ = 0;
393    rowNames_ = std::vector<std::string> ();
394    columnNames_ = std::vector<std::string> ();
395    integerType_ = NULL;
396  }
397}
398/* Borrow model.  This is so we dont have to copy large amounts
399   of data around.  It assumes a derived class wants to overwrite
400   an empty model with a real one - while it does an algorithm */
401void 
402ClpModel::borrowModel(ClpModel & rhs)
403{
404  if (defaultHandler_) {
405    delete handler_;
406    handler_ = NULL;
407  }
408  gutsOfDelete();
409  optimizationDirection_ = rhs.optimizationDirection_;
410  numberRows_ = rhs.numberRows_;
411  numberColumns_ = rhs.numberColumns_;
412  delete [] rhs.ray_;
413  rhs.ray_=NULL;
414  gutsOfCopy(rhs,false);
415}
416// Return model - nulls all arrays so can be deleted safely
417void 
418ClpModel::returnModel(ClpModel & otherModel)
419{
420  otherModel.objectiveValue_=objectiveValue_;
421  otherModel.numberIterations_ = numberIterations_;
422  otherModel.problemStatus_ = problemStatus_;
423  rowActivity_ = NULL;
424  columnActivity_ = NULL;
425  dual_ = NULL;
426  reducedCost_ = NULL;
427  rowLower_ = NULL;
428  rowUpper_ = NULL;
429  objective_ = NULL;
430  rowObjective_ = NULL;
431  columnLower_ = NULL;
432  columnUpper_ = NULL;
433  matrix_ = NULL;
434  rowCopy_ = NULL;
435  delete [] otherModel.ray_;
436  otherModel.ray_ = ray_;
437  ray_ = NULL;
438}
439//#############################################################################
440// Parameter related methods
441//#############################################################################
442
443bool
444ClpModel::setIntParam(OsiIntParam key, int value)
445{
446  switch (key) {
447  case OsiMaxNumIteration:
448    if (value < 0)
449      return false;
450    break;
451  case OsiMaxNumIterationHotStart:
452    if (value < 0)
453      return false;
454    break;
455  case OsiLastIntParam:
456    return false;
457  }
458  intParam_[key] = value;
459  return true;
460}
461
462//-----------------------------------------------------------------------------
463
464bool
465ClpModel::setDblParam(OsiDblParam key, double value)
466{
467
468  switch (key) {
469  case OsiDualObjectiveLimit:
470    break;
471
472  case OsiPrimalObjectiveLimit:
473    break;
474
475  case OsiDualTolerance: 
476    if (value<=0.0||value>1.0e10)
477      return false;
478    break;
479   
480  case OsiPrimalTolerance: 
481    if (value<=0.0||value>1.0e10)
482      return false;
483    break;
484   
485  case OsiObjOffset: 
486    break;
487
488  case OsiLastDblParam:
489    return false;
490  }
491  dblParam_[key] = value;
492  return true;
493}
494
495//-----------------------------------------------------------------------------
496
497bool
498ClpModel::setStrParam(OsiStrParam key, const std::string & value)
499{
500
501  switch (key) {
502  case OsiProbName:
503    break;
504
505  case OsiLastStrParam:
506    return false;
507  }
508  strParam_[key] = value;
509  return true;
510}
511// Useful routines
512// Returns resized array and deletes incoming
513double * resizeDouble(double * array , int size, int newSize, double fill)
514{
515  if (array&&size!=newSize) {
516    int i;
517    double * newArray = new double[newSize];
518    memcpy(newArray,array,min(newSize,size)*sizeof(double));
519    delete [] array;
520    array = newArray;
521    for (i=size;i<newSize;i++) 
522      array[i]=fill;
523  } 
524  return array;
525}
526// Returns resized array and updates size
527double * deleteDouble(double * array , int size, 
528                      int number, const int * which,int & newSize)
529{
530  if (array) {
531    int i ;
532    char * deleted = new char[size];
533    int numberDeleted=0;
534    memset(deleted,0,size*sizeof(char));
535    for (i=0;i<number;i++) {
536      int j = which[i];
537      if (j>=0&&j<size&&!deleted[j]) {
538        numberDeleted++;
539        deleted[j]=1;
540      }
541    }
542    newSize = size-numberDeleted;
543    double * newArray = new double[newSize];
544    int put=0;
545    for (i=0;i<size;i++) {
546      if (!deleted[i]) {
547        newArray[put++]=array[i];
548      }
549    }
550    delete [] array;
551    array = newArray;
552    delete [] deleted;
553  }
554  return array;
555}
556char * deleteChar(char * array , int size, 
557                      int number, const int * which,int & newSize)
558{
559  if (array) {
560    int i ;
561    char * deleted = new char[size];
562    int numberDeleted=0;
563    memset(deleted,0,size*sizeof(char));
564    for (i=0;i<number;i++) {
565      int j = which[i];
566      if (j>=0&&j<size&&!deleted[j]) {
567        numberDeleted++;
568        deleted[j]=1;
569      }
570    }
571    newSize = size-numberDeleted;
572    char * newArray = new char[newSize];
573    int put=0;
574    for (i=0;i<size;i++) {
575      if (!deleted[i]) {
576        newArray[put++]=array[i];
577      }
578    }
579    delete [] array;
580    array = newArray;
581    delete [] deleted;
582  }
583  return array;
584}
585// Resizes
586void 
587ClpModel::resize (int newNumberRows, int newNumberColumns)
588{
589  rowActivity_ = resizeDouble(rowActivity_,numberRows_,
590                              newNumberRows,0.0);
591  dual_ = resizeDouble(dual_,numberRows_,
592                       newNumberRows,0.0);
593  rowObjective_ = resizeDouble(rowObjective_,numberRows_,
594                               newNumberRows,0.0);
595  rowLower_ = resizeDouble(rowLower_,numberRows_,
596                           newNumberRows,-DBL_MAX);
597  rowUpper_ = resizeDouble(rowUpper_,numberRows_,
598                           newNumberRows,DBL_MAX);
599  columnActivity_ = resizeDouble(columnActivity_,numberColumns_,
600                                 newNumberColumns,0.0);
601  reducedCost_ = resizeDouble(reducedCost_,numberColumns_,
602                              newNumberColumns,0.0);
603  objective_ = resizeDouble(objective_,numberColumns_,
604                            newNumberColumns,0.0);
605  columnLower_ = resizeDouble(columnLower_,numberColumns_,
606                              newNumberColumns,0.0);
607  columnUpper_ = resizeDouble(columnUpper_,numberColumns_,
608                              newNumberColumns,DBL_MAX);
609  if (newNumberRows<numberRows_) {
610    int * which = new int[numberRows_-newNumberRows];
611    int i;
612    for (i=newNumberRows;i<numberRows_;i++) 
613      which[i-newNumberRows]=i;
614    matrix_->deleteRows(numberRows_-newNumberRows,which);
615    delete [] which;
616  }
617  if (numberRows_!=newNumberRows||numberColumns_!=newNumberColumns) {
618    // set state back to unknown
619    problemStatus_ = -1;
620    delete [] ray_;
621    ray_ = NULL;
622  }
623  numberRows_ = newNumberRows;
624  if (newNumberColumns<numberColumns_) {
625    int * which = new int[numberColumns_-newNumberColumns];
626    int i;
627    for (i=newNumberColumns;i<numberColumns_;i++) 
628      which[i-newNumberColumns]=i;
629    matrix_->deleteCols(numberColumns_-newNumberColumns,which);
630    delete [] which;
631  }
632  if (integerType_) {
633    char * temp = new char [newNumberColumns];
634    memset(temp,0,newNumberColumns*sizeof(char));
635    memcpy(temp,integerType_,
636           min(newNumberColumns,numberColumns_)*sizeof(char));
637    delete [] integerType_;
638    integerType_ = temp;
639  }
640  numberColumns_ = newNumberColumns;
641  // for now gets rid of names
642  lengthNames_ = 0;
643  rowNames_ = std::vector<std::string> ();
644  columnNames_ = std::vector<std::string> ();
645}
646// Deletes rows
647void 
648ClpModel::deleteRows(int number, const int * which)
649{
650  int newSize=0;
651  rowActivity_ = deleteDouble(rowActivity_,numberRows_,
652                              number, which, newSize);
653  dual_ = deleteDouble(dual_,numberRows_,
654                              number, which, newSize);
655  rowObjective_ = deleteDouble(rowObjective_,numberRows_,
656                              number, which, newSize);
657  rowLower_ = deleteDouble(rowLower_,numberRows_,
658                              number, which, newSize);
659  rowUpper_ = deleteDouble(rowUpper_,numberRows_,
660                              number, which, newSize);
661  matrix_->deleteRows(number,which);
662  numberRows_=newSize;
663  // set state back to unknown
664  problemStatus_ = -1;
665  delete [] ray_;
666  ray_ = NULL;
667  // for now gets rid of names
668  lengthNames_ = 0;
669  rowNames_ = std::vector<std::string> ();
670  columnNames_ = std::vector<std::string> ();
671}
672// Deletes columns
673void 
674ClpModel::deleteColumns(int number, const int * which)
675{
676  int newSize=0;
677  columnActivity_ = deleteDouble(columnActivity_,numberColumns_,
678                              number, which, newSize);
679  reducedCost_ = deleteDouble(reducedCost_,numberColumns_,
680                              number, which, newSize);
681  objective_ = deleteDouble(objective_,numberColumns_,
682                              number, which, newSize);
683  columnLower_ = deleteDouble(columnLower_,numberColumns_,
684                              number, which, newSize);
685  columnUpper_ = deleteDouble(columnUpper_,numberColumns_,
686                              number, which, newSize);
687  matrix_->deleteCols(number,which);
688  numberColumns_=newSize;
689  // set state back to unknown
690  problemStatus_ = -1;
691  delete [] ray_;
692  ray_ = NULL;
693  // for now gets rid of names
694  lengthNames_ = 0;
695  rowNames_ = std::vector<std::string> ();
696  columnNames_ = std::vector<std::string> ();
697  integerType_ = deleteChar(integerType_,numberColumns_,
698                            number, which, newSize);
699}
700// Infeasibility/unbounded ray (NULL returned if none/wrong)
701double * 
702ClpModel::infeasibilityRay() const
703{
704  double * array = NULL;
705  if (problemStatus_==1) 
706    array = copyOfArray(ray_,numberRows_);
707  return array;
708}
709double * 
710ClpModel::unboundedRay() const
711{
712  double * array = NULL;
713  if (problemStatus_==2) 
714    array = copyOfArray(ray_,numberColumns_);
715  return array;
716}
717void 
718ClpModel::setMaximumIterations(int value)
719{
720  if(value>=0)
721    maximumIterations_=value;
722}
723// Pass in Message handler (not deleted at end)
724void 
725ClpModel::passInMessageHandler(OsiMessageHandler * handler)
726{
727  defaultHandler_=false;
728  handler_=handler;
729}
730// Set language
731void 
732ClpModel::newLanguage(OsiMessages::Language language)
733{
734  messages_ = ClpMessage(language);
735}
736// Read an mps file from the given filename
737int 
738ClpModel::readMps(const char *fileName,
739                  bool keepNames,
740                  bool ignoreErrors)
741{
742  bool canOpen=false;
743  if (fileName=="-") {
744    // stdin
745    canOpen=true;
746    fileName = "-";
747  } else {
748    FILE *fp=fopen(fileName,"r");
749    if (fp) {
750      // can open - lets go for it
751      fclose(fp);
752      canOpen=true;
753    } else {
754      handler_->message(CLP_UNABLE_OPEN,messages_)
755        <<fileName<<OsiMessageEol;
756      return -1;
757    }
758  }
759  OsiMpsReader m;
760  double time1 = cpuTime(),time2;
761  int status=m.readMps(fileName,"");
762  if (!status||ignoreErrors) {
763    loadProblem(*m.getMatrixByCol(),
764                m.getColLower(),m.getColUpper(),
765                m.getObjCoefficients(),
766                m.getRowLower(),m.getRowUpper());
767    if (m.integerColumns()) {
768      integerType_ = new char[numberColumns_];
769      memcpy(integerType_,m.integerColumns(),numberColumns_*sizeof(char));
770    } else {
771      integerType_ = NULL;
772    }
773    // set problem name
774    setStrParam(OsiProbName,m.getProblemName());
775    // do names
776    if (keepNames) {
777      unsigned int maxLength=0;
778      int iRow;
779      rowNames_.reserve(numberRows_);
780      for (iRow=0;iRow<numberRows_;iRow++) {
781        const char * name = m.rowName(iRow);
782        maxLength = max(maxLength,(unsigned int) strlen(name));
783          rowNames_.push_back(name);
784      }
785     
786      int iColumn;
787      columnNames_.reserve(numberColumns_);
788      for (iColumn=0;iColumn<numberColumns_;iColumn++) {
789        const char * name = m.columnName(iColumn);
790        maxLength = max(maxLength,(unsigned int) strlen(name));
791        columnNames_.push_back(name);
792      }
793      lengthNames_=(int) maxLength;
794    } else {
795      lengthNames_=0;
796    }
797    setDblParam(OsiObjOffset,m.objectiveOffset());
798    time2 = cpuTime();
799    handler_->message(CLP_IMPORT_RESULT,messages_)
800      <<fileName
801      <<time2-time1<<OsiMessageEol;
802  } else {
803    // errors
804    handler_->message(CLP_IMPORT_ERRORS,messages_)
805      <<status<<fileName<<OsiMessageEol;
806  }
807
808  return status;
809}
810bool ClpModel::isPrimalObjectiveLimitReached() const
811{
812  double limit = 0.0;
813  getDblParam(OsiPrimalObjectiveLimit, limit);
814  if (limit > 1e30) {
815    // was not ever set
816    return false;
817  }
818   
819  const double obj = objectiveValue();
820  const int maxmin = optimizationDirection();
821
822  if (problemStatus_ == 0) // optimal
823    return maxmin > 0 ? (obj < limit) /*minim*/ : (obj > limit) /*maxim*/;
824  else if (problemStatus_==2)
825    return true;
826  else
827    return false;
828}
829
830bool ClpModel::isDualObjectiveLimitReached() const
831{
832
833  double limit = 0.0;
834  getDblParam(OsiDualObjectiveLimit, limit);
835  if (limit > 1e30) {
836    // was not ever set
837    return false;
838  }
839   
840  const double obj = objectiveValue();
841  const int maxmin = optimizationDirection();
842
843  if (problemStatus_ == 0) // optimal
844    return maxmin > 0 ? (obj > limit) /*minim*/ : (obj < limit) /*maxim*/;
845  else if (problemStatus_==1)
846    return true;
847  else
848    return false;
849
850}
Note: See TracBrowser for help on using the repository browser.