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

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

reordering Clp

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