source: tags/release_2002-11-05/ClpModel.cpp @ 778

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

devel-1 merged into HEAD

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 25.4 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
27static double cpuTime()
28{
29  double cpu_temp;
30#if defined(_MSC_VER)
31  unsigned int ticksnow;        /* clock_t is same as int */
32 
33  ticksnow = (unsigned int)clock();
34 
35  cpu_temp = (double)((double)ticksnow/CLOCKS_PER_SEC);
36#else
37  struct rusage usage;
38  getrusage(RUSAGE_SELF,&usage);
39  cpu_temp = usage.ru_utime.tv_sec;
40  cpu_temp += 1.0e-6*((double) usage.ru_utime.tv_usec);
41#endif
42  return cpu_temp;
43}
44//#############################################################################
45
46ClpModel::ClpModel () :
47
48  optimizationDirection_(1),
49  numberRows_(0),
50  numberColumns_(0),
51  rowActivity_(NULL),
52  columnActivity_(NULL),
53  dual_(NULL),
54  reducedCost_(NULL),
55  rowLower_(NULL),
56  rowUpper_(NULL),
57  objective_(NULL),
58  rowObjective_(NULL),
59  columnLower_(NULL),
60  columnUpper_(NULL),
61  matrix_(NULL),
62  rowCopy_(NULL),
63  ray_(NULL),
64  objectiveValue_(0.0),
65  numberIterations_(0),
66  problemStatus_(-1),
67  maximumIterations_(1000000000),
68  defaultHandler_(true),
69  status_(NULL),
70  lengthNames_(0),
71  rowNames_(),
72  columnNames_(),
73  integerType_(NULL)
74{
75  intParam_[ClpMaxNumIteration] = 9999999;
76  intParam_[ClpMaxNumIterationHotStart] = 9999999;
77
78  dblParam_[ClpDualObjectiveLimit] = DBL_MAX;
79  dblParam_[ClpPrimalObjectiveLimit] = DBL_MAX;
80  dblParam_[ClpDualTolerance] = 1e-7;
81  dblParam_[ClpPrimalTolerance] = 1e-7;
82  dblParam_[ClpObjOffset] = 0.0;
83
84  strParam_[ClpProbName] = "ClpDefaultName";
85  handler_ = new CoinMessageHandler();
86  handler_->setLogLevel(2);
87  messages_ = ClpMessage();
88}
89
90//-----------------------------------------------------------------------------
91
92ClpModel::~ClpModel ()
93{
94  if (defaultHandler_) {
95    delete handler_;
96    handler_ = NULL;
97  }
98  gutsOfDelete();
99}
100void ClpModel::gutsOfDelete()
101{
102  delete [] rowActivity_;
103  rowActivity_=NULL;
104  delete [] columnActivity_;
105  columnActivity_=NULL;
106  delete [] dual_;
107  dual_=NULL;
108  delete [] reducedCost_;
109  reducedCost_=NULL;
110  delete [] rowLower_;
111  delete [] rowUpper_;
112  delete [] rowObjective_;
113  rowLower_=NULL;
114  rowUpper_=NULL;
115  rowObjective_=NULL;
116  delete [] columnLower_;
117  delete [] columnUpper_;
118  delete [] objective_;
119  columnLower_=NULL;
120  columnUpper_=NULL;
121  objective_=NULL;
122  delete matrix_;
123  matrix_=NULL;
124  delete rowCopy_;
125  rowCopy_=NULL;
126  delete [] ray_;
127  ray_ = NULL;
128  delete [] integerType_;
129  integerType_ = NULL;
130  delete [] status_;
131  status_=NULL;
132}
133//#############################################################################
134void ClpModel::setPrimalTolerance( double value) 
135{
136  if (value>0.0&&value<1.0e10)
137    dblParam_[ClpPrimalTolerance]=value;
138}
139void ClpModel::setDualTolerance( double value) 
140{
141  if (value>0.0&&value<1.0e10)
142    dblParam_[ClpDualTolerance]=value;
143}
144void ClpModel::setOptimizationDirection( int value) 
145{
146  if (value>=-1&&value<=1)
147    optimizationDirection_=value;
148}
149void
150ClpModel::gutsOfLoadModel (int numberRows, int numberColumns, 
151                     const double* collb, const double* colub,   
152                     const double* obj,
153                     const double* rowlb, const double* rowub,
154                                const double * rowObjective)
155{
156  gutsOfDelete();
157  numberRows_=numberRows;
158  numberColumns_=numberColumns;
159  rowActivity_=new double[numberRows_];
160  columnActivity_=new double[numberColumns_];
161  dual_=new double[numberRows_];
162  reducedCost_=new double[numberColumns_];
163
164  ClpFillN(dual_,numberRows_,0.0);
165  ClpFillN(reducedCost_,numberColumns_,0.0);
166  int iRow,iColumn;
167
168  rowLower_=ClpCopyOfArray(rowlb,numberRows_,-DBL_MAX);
169  rowUpper_=ClpCopyOfArray(rowub,numberRows_,DBL_MAX);
170  objective_=ClpCopyOfArray(obj,numberColumns_,0.0);
171  rowObjective_=ClpCopyOfArray(rowObjective,numberRows_);
172  columnLower_=ClpCopyOfArray(collb,numberColumns_,0.0);
173  columnUpper_=ClpCopyOfArray(colub,numberColumns_,DBL_MAX);
174  // set default solution
175  for (iRow=0;iRow<numberRows_;iRow++) {
176    if (rowLower_[iRow]>0.0) {
177      rowActivity_[iRow]=rowLower_[iRow];
178    } else if (rowUpper_[iRow]<0.0) {
179      rowActivity_[iRow]=rowUpper_[iRow];
180    } else {
181      rowActivity_[iRow]=0.0;
182    }
183  }
184  for (iColumn=0;iColumn<numberColumns_;iColumn++) {
185    if (columnLower_[iColumn]>0.0) {
186      columnActivity_[iColumn]=columnLower_[iColumn];
187    } else if (columnUpper_[iColumn]<0.0) {
188      columnActivity_[iColumn]=columnUpper_[iColumn];
189    } else {
190      columnActivity_[iColumn]=0.0;
191    }
192  }
193}
194void
195ClpModel::loadProblem (  const ClpMatrixBase& matrix,
196                     const double* collb, const double* colub,   
197                     const double* obj,
198                     const double* rowlb, const double* rowub,
199                                const double * rowObjective)
200{
201  gutsOfLoadModel(matrix.getNumRows(),matrix.getNumCols(),
202                  collb, colub, obj, rowlb, rowub, rowObjective);
203  if (matrix.isColOrdered()) {
204    matrix_=matrix.clone();
205  } else {
206    // later may want to keep as unknown class
207    CoinPackedMatrix matrix2;
208    matrix2.reverseOrderedCopyOf(*matrix.getPackedMatrix());
209    matrix.releasePackedMatrix();
210    matrix_=new ClpPackedMatrix(matrix2);
211  }   
212}
213void
214ClpModel::loadProblem (  const CoinPackedMatrix& matrix,
215                     const double* collb, const double* colub,   
216                     const double* obj,
217                     const double* rowlb, const double* rowub,
218                                const double * rowObjective)
219{
220  gutsOfLoadModel(matrix.getNumRows(),matrix.getNumCols(),
221                  collb, colub, obj, rowlb, rowub, rowObjective);
222  if (matrix.isColOrdered()) {
223    matrix_=new ClpPackedMatrix(matrix);
224  } else {
225    CoinPackedMatrix matrix2;
226    matrix2.reverseOrderedCopyOf(matrix);
227    matrix_=new ClpPackedMatrix(matrix2);
228  }   
229}
230void
231ClpModel::loadProblem ( 
232                              const int numcols, const int numrows,
233                              const CoinBigIndex* start, const int* index,
234                              const double* value,
235                              const double* collb, const double* colub,   
236                              const double* obj,
237                              const double* rowlb, const double* rowub,
238                              const double * rowObjective)
239{
240  gutsOfLoadModel(numrows, numcols,
241                  collb, colub, obj, rowlb, rowub, rowObjective);
242  CoinPackedMatrix matrix(true,numrows,numcols,start[numcols],
243                              value,index,start,NULL);
244  matrix_ = new ClpPackedMatrix(matrix);
245}
246void
247ClpModel::loadProblem ( 
248                              const int numcols, const int numrows,
249                              const CoinBigIndex* start, const int* index,
250                              const double* value,const int* length,
251                              const double* collb, const double* colub,   
252                              const double* obj,
253                              const double* rowlb, const double* rowub,
254                              const double * rowObjective)
255{
256  gutsOfLoadModel(numrows, numcols,
257                  collb, colub, obj, rowlb, rowub, rowObjective);
258  // Compute number of elements
259  int numberElements = 0;
260  int i;
261  for (i=0;i<numcols;i++) 
262    numberElements += length[i];
263  CoinPackedMatrix matrix(true,numrows,numcols,numberElements,
264                              value,index,start,length);
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 CoinMessageHandler(*rhs.handler_);
310   else 
311    handler_ = rhs.handler_;
312  messages_ = rhs.messages_;
313  intParam_[ClpMaxNumIteration] = rhs.intParam_[ClpMaxNumIteration];
314  intParam_[ClpMaxNumIterationHotStart] = 
315    rhs.intParam_[ClpMaxNumIterationHotStart];
316
317  dblParam_[ClpDualObjectiveLimit] = rhs.dblParam_[ClpDualObjectiveLimit];
318  dblParam_[ClpPrimalObjectiveLimit] = rhs.dblParam_[ClpPrimalObjectiveLimit];
319  dblParam_[ClpDualTolerance] = rhs.dblParam_[ClpDualTolerance];
320  dblParam_[ClpPrimalTolerance] = rhs.dblParam_[ClpPrimalTolerance];
321  dblParam_[ClpObjOffset] = rhs.dblParam_[ClpObjOffset];
322
323  strParam_[ClpProbName] = rhs.strParam_[ClpProbName];
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      ClpDisjointCopyN ( rhs.rowActivity_, numberRows_ ,
345                          rowActivity_);
346      ClpDisjointCopyN ( rhs.columnActivity_, numberColumns_ ,
347                          columnActivity_);
348      ClpDisjointCopyN ( rhs.dual_, numberRows_ , 
349                          dual_);
350      ClpDisjointCopyN ( rhs.reducedCost_, numberColumns_ ,
351                          reducedCost_);
352    } else {
353      rowActivity_=NULL;
354      columnActivity_=NULL;
355      dual_=NULL;
356      reducedCost_=NULL;
357    }
358    rowLower_ = ClpCopyOfArray ( rhs.rowLower_, numberRows_ );
359    rowUpper_ = ClpCopyOfArray ( rhs.rowUpper_, numberRows_ );
360    columnLower_ = ClpCopyOfArray ( rhs.columnLower_, numberColumns_ );
361    columnUpper_ = ClpCopyOfArray ( rhs.columnUpper_, numberColumns_ );
362    objective_ = ClpCopyOfArray ( rhs.objective_, numberColumns_ );
363    rowObjective_ = ClpCopyOfArray ( rhs.rowObjective_, numberRows_ );
364    status_ = ClpCopyOfArray( rhs.status_,numberColumns_+numberRows_);
365    ray_ = NULL;
366    if (problemStatus_==1)
367      ray_ = ClpCopyOfArray (rhs.ray_,numberRows_);
368    else if (problemStatus_==2)
369      ray_ = ClpCopyOfArray (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    status_ = rhs.status_;
398  }
399}
400/* Borrow model.  This is so we dont have to copy large amounts
401   of data around.  It assumes a derived class wants to overwrite
402   an empty model with a real one - while it does an algorithm */
403void 
404ClpModel::borrowModel(ClpModel & rhs)
405{
406  if (defaultHandler_) {
407    delete handler_;
408    handler_ = NULL;
409  }
410  gutsOfDelete();
411  optimizationDirection_ = rhs.optimizationDirection_;
412  numberRows_ = rhs.numberRows_;
413  numberColumns_ = rhs.numberColumns_;
414  delete [] rhs.ray_;
415  rhs.ray_=NULL;
416  gutsOfCopy(rhs,false);
417}
418// Return model - nulls all arrays so can be deleted safely
419void 
420ClpModel::returnModel(ClpModel & otherModel)
421{
422  otherModel.objectiveValue_=objectiveValue_;
423  otherModel.numberIterations_ = numberIterations_;
424  otherModel.problemStatus_ = problemStatus_;
425  rowActivity_ = NULL;
426  columnActivity_ = NULL;
427  dual_ = NULL;
428  reducedCost_ = NULL;
429  rowLower_ = NULL;
430  rowUpper_ = NULL;
431  objective_ = NULL;
432  rowObjective_ = NULL;
433  columnLower_ = NULL;
434  columnUpper_ = NULL;
435  matrix_ = NULL;
436  rowCopy_ = NULL;
437  delete [] otherModel.ray_;
438  otherModel.ray_ = ray_;
439  ray_ = NULL;
440  // do status
441  if (otherModel.status_!=status_) {
442    delete [] otherModel.status_;
443    otherModel.status_ = status_;
444  }
445  status_ = NULL;
446}
447//#############################################################################
448// Parameter related methods
449//#############################################################################
450
451bool
452ClpModel::setIntParam(ClpIntParam key, int value)
453{
454  switch (key) {
455  case ClpMaxNumIteration:
456    if (value < 0)
457      return false;
458    break;
459  case ClpMaxNumIterationHotStart:
460    if (value < 0)
461      return false;
462    break;
463  case ClpLastIntParam:
464    return false;
465  }
466  intParam_[key] = value;
467  return true;
468}
469
470//-----------------------------------------------------------------------------
471
472bool
473ClpModel::setDblParam(ClpDblParam key, double value)
474{
475
476  switch (key) {
477  case ClpDualObjectiveLimit:
478    break;
479
480  case ClpPrimalObjectiveLimit:
481    break;
482
483  case ClpDualTolerance: 
484    if (value<=0.0||value>1.0e10)
485      return false;
486    break;
487   
488  case ClpPrimalTolerance: 
489    if (value<=0.0||value>1.0e10)
490      return false;
491    break;
492   
493  case ClpObjOffset: 
494    break;
495
496  case ClpLastDblParam:
497    return false;
498  }
499  dblParam_[key] = value;
500  return true;
501}
502
503//-----------------------------------------------------------------------------
504
505bool
506ClpModel::setStrParam(ClpStrParam key, const std::string & value)
507{
508
509  switch (key) {
510  case ClpProbName:
511    break;
512
513  case ClpLastStrParam:
514    return false;
515  }
516  strParam_[key] = value;
517  return true;
518}
519// Useful routines
520// Returns resized array and deletes incoming
521double * resizeDouble(double * array , int size, int newSize, double fill)
522{
523  if (array&&size!=newSize) {
524    int i;
525    double * newArray = new double[newSize];
526    memcpy(newArray,array,min(newSize,size)*sizeof(double));
527    delete [] array;
528    array = newArray;
529    for (i=size;i<newSize;i++) 
530      array[i]=fill;
531  } 
532  return array;
533}
534// Returns resized array and updates size
535double * deleteDouble(double * array , int size, 
536                      int number, const int * which,int & newSize)
537{
538  if (array) {
539    int i ;
540    char * deleted = new char[size];
541    int numberDeleted=0;
542    memset(deleted,0,size*sizeof(char));
543    for (i=0;i<number;i++) {
544      int j = which[i];
545      if (j>=0&&j<size&&!deleted[j]) {
546        numberDeleted++;
547        deleted[j]=1;
548      }
549    }
550    newSize = size-numberDeleted;
551    double * newArray = new double[newSize];
552    int put=0;
553    for (i=0;i<size;i++) {
554      if (!deleted[i]) {
555        newArray[put++]=array[i];
556      }
557    }
558    delete [] array;
559    array = newArray;
560    delete [] deleted;
561  }
562  return array;
563}
564char * deleteChar(char * array , int size, 
565                  int number, const int * which,int & newSize,
566                  bool ifDelete)
567{
568  if (array) {
569    int i ;
570    char * deleted = new char[size];
571    int numberDeleted=0;
572    memset(deleted,0,size*sizeof(char));
573    for (i=0;i<number;i++) {
574      int j = which[i];
575      if (j>=0&&j<size&&!deleted[j]) {
576        numberDeleted++;
577        deleted[j]=1;
578      }
579    }
580    newSize = size-numberDeleted;
581    char * newArray = new char[newSize];
582    int put=0;
583    for (i=0;i<size;i++) {
584      if (!deleted[i]) {
585        newArray[put++]=array[i];
586      }
587    }
588    if (ifDelete)
589      delete [] array;
590    array = newArray;
591    delete [] deleted;
592  }
593  return array;
594}
595// Resizes
596void 
597ClpModel::resize (int newNumberRows, int newNumberColumns)
598{
599  rowActivity_ = resizeDouble(rowActivity_,numberRows_,
600                              newNumberRows,0.0);
601  dual_ = resizeDouble(dual_,numberRows_,
602                       newNumberRows,0.0);
603  rowObjective_ = resizeDouble(rowObjective_,numberRows_,
604                               newNumberRows,0.0);
605  rowLower_ = resizeDouble(rowLower_,numberRows_,
606                           newNumberRows,-DBL_MAX);
607  rowUpper_ = resizeDouble(rowUpper_,numberRows_,
608                           newNumberRows,DBL_MAX);
609  columnActivity_ = resizeDouble(columnActivity_,numberColumns_,
610                                 newNumberColumns,0.0);
611  reducedCost_ = resizeDouble(reducedCost_,numberColumns_,
612                              newNumberColumns,0.0);
613  objective_ = resizeDouble(objective_,numberColumns_,
614                            newNumberColumns,0.0);
615  columnLower_ = resizeDouble(columnLower_,numberColumns_,
616                              newNumberColumns,0.0);
617  columnUpper_ = resizeDouble(columnUpper_,numberColumns_,
618                              newNumberColumns,DBL_MAX);
619  if (newNumberRows<numberRows_) {
620    int * which = new int[numberRows_-newNumberRows];
621    int i;
622    for (i=newNumberRows;i<numberRows_;i++) 
623      which[i-newNumberRows]=i;
624    matrix_->deleteRows(numberRows_-newNumberRows,which);
625    delete [] which;
626  }
627  if (numberRows_!=newNumberRows||numberColumns_!=newNumberColumns) {
628    // set state back to unknown
629    problemStatus_ = -1;
630    delete [] ray_;
631    ray_ = NULL;
632  }
633  if (status_) {
634    unsigned char * tempC = new unsigned char [newNumberColumns+newNumberRows];
635    unsigned char * tempR = tempC + newNumberColumns;
636    memset(tempC,0,(newNumberColumns+newNumberRows)*sizeof(unsigned char));
637    memcpy(tempC,status_,min(newNumberColumns,numberColumns_)*sizeof(unsigned char));
638    memcpy(tempR,status_+numberColumns_,min(newNumberRows,numberRows_)*sizeof(unsigned char));
639    delete [] status_;
640    status_ = tempC;
641  }
642  numberRows_ = newNumberRows;
643  if (newNumberColumns<numberColumns_) {
644    int * which = new int[numberColumns_-newNumberColumns];
645    int i;
646    for (i=newNumberColumns;i<numberColumns_;i++) 
647      which[i-newNumberColumns]=i;
648    matrix_->deleteCols(numberColumns_-newNumberColumns,which);
649    delete [] which;
650  }
651  if (integerType_) {
652    char * temp = new char [newNumberColumns];
653    memset(temp,0,newNumberColumns*sizeof(char));
654    memcpy(temp,integerType_,
655           min(newNumberColumns,numberColumns_)*sizeof(char));
656    delete [] integerType_;
657    integerType_ = temp;
658  }
659  numberColumns_ = newNumberColumns;
660  // for now gets rid of names
661  lengthNames_ = 0;
662  rowNames_ = std::vector<std::string> ();
663  columnNames_ = std::vector<std::string> ();
664}
665// Deletes rows
666void 
667ClpModel::deleteRows(int number, const int * which)
668{
669  int newSize=0;
670  rowActivity_ = deleteDouble(rowActivity_,numberRows_,
671                              number, which, newSize);
672  dual_ = deleteDouble(dual_,numberRows_,
673                              number, which, newSize);
674  rowObjective_ = deleteDouble(rowObjective_,numberRows_,
675                              number, which, newSize);
676  rowLower_ = deleteDouble(rowLower_,numberRows_,
677                              number, which, newSize);
678  rowUpper_ = deleteDouble(rowUpper_,numberRows_,
679                              number, which, newSize);
680  matrix_->deleteRows(number,which);
681  numberRows_=newSize;
682  // set state back to unknown
683  problemStatus_ = -1;
684  delete [] ray_;
685  ray_ = NULL;
686  // for now gets rid of names
687  lengthNames_ = 0;
688  rowNames_ = std::vector<std::string> ();
689  columnNames_ = std::vector<std::string> ();
690  // status
691  if (status_) {
692    unsigned char * tempR  = (unsigned char *) deleteChar((char *)status_+numberColumns_,
693                                        numberRows_,
694                                        number, which, newSize,false);
695    unsigned char * tempC = new unsigned char [numberColumns_+newSize];
696    memcpy(tempC,status_,numberColumns_*sizeof(unsigned char));
697    memcpy(tempC+numberColumns_,tempR,newSize*sizeof(unsigned char));
698    delete [] tempR;
699    delete [] status_;
700    status_ = tempC;
701  }
702}
703// Deletes columns
704void 
705ClpModel::deleteColumns(int number, const int * which)
706{
707  int newSize=0;
708  columnActivity_ = deleteDouble(columnActivity_,numberColumns_,
709                              number, which, newSize);
710  reducedCost_ = deleteDouble(reducedCost_,numberColumns_,
711                              number, which, newSize);
712  objective_ = deleteDouble(objective_,numberColumns_,
713                              number, which, newSize);
714  columnLower_ = deleteDouble(columnLower_,numberColumns_,
715                              number, which, newSize);
716  columnUpper_ = deleteDouble(columnUpper_,numberColumns_,
717                              number, which, newSize);
718  matrix_->deleteCols(number,which);
719  numberColumns_=newSize;
720  // set state back to unknown
721  problemStatus_ = -1;
722  delete [] ray_;
723  ray_ = NULL;
724  // for now gets rid of names
725  lengthNames_ = 0;
726  rowNames_ = std::vector<std::string> ();
727  columnNames_ = std::vector<std::string> ();
728  integerType_ = deleteChar(integerType_,numberColumns_,
729                            number, which, newSize,true);
730  // status
731  if (status_) {
732    unsigned char * tempC  = (unsigned char *) deleteChar((char *)status_,
733                                        numberColumns_,
734                                        number, which, newSize,false);
735    unsigned char * temp = new unsigned char [numberRows_+newSize];
736    memcpy(temp,status_,newSize*sizeof(unsigned char));
737    memcpy(temp+newSize,status_+numberColumns_,
738           numberRows_*sizeof(unsigned char));
739    delete [] tempC;
740    delete [] status_;
741    status_ = temp;
742  }
743}
744// Infeasibility/unbounded ray (NULL returned if none/wrong)
745double * 
746ClpModel::infeasibilityRay() const
747{
748  double * array = NULL;
749  if (problemStatus_==1) 
750    array = ClpCopyOfArray(ray_,numberRows_);
751  return array;
752}
753double * 
754ClpModel::unboundedRay() const
755{
756  double * array = NULL;
757  if (problemStatus_==2) 
758    array = ClpCopyOfArray(ray_,numberColumns_);
759  return array;
760}
761void 
762ClpModel::setMaximumIterations(int value)
763{
764  if(value>=0)
765    maximumIterations_=value;
766}
767// Pass in Message handler (not deleted at end)
768void 
769ClpModel::passInMessageHandler(CoinMessageHandler * handler)
770{
771  defaultHandler_=false;
772  handler_=handler;
773}
774// Set language
775void 
776ClpModel::newLanguage(CoinMessages::Language language)
777{
778  messages_ = ClpMessage(language);
779}
780// Read an mps file from the given filename
781int 
782ClpModel::readMps(const char *fileName,
783                  bool keepNames,
784                  bool ignoreErrors)
785{
786  bool canOpen=false;
787  if (fileName=="-") {
788    // stdin
789    canOpen=true;
790    fileName = "-";
791  } else {
792    FILE *fp=fopen(fileName,"r");
793    if (fp) {
794      // can open - lets go for it
795      fclose(fp);
796      canOpen=true;
797    } else {
798      handler_->message(CLP_UNABLE_OPEN,messages_)
799        <<fileName<<CoinMessageEol;
800      return -1;
801    }
802  }
803  CoinMpsIO m;
804  double time1 = cpuTime(),time2;
805  int status=m.readMps(fileName,"");
806  if (!status||ignoreErrors) {
807    loadProblem(*m.getMatrixByCol(),
808                m.getColLower(),m.getColUpper(),
809                m.getObjCoefficients(),
810                m.getRowLower(),m.getRowUpper());
811    if (m.integerColumns()) {
812      integerType_ = new char[numberColumns_];
813      memcpy(integerType_,m.integerColumns(),numberColumns_*sizeof(char));
814    } else {
815      integerType_ = NULL;
816    }
817    // set problem name
818    setStrParam(ClpProbName,m.getProblemName());
819    // do names
820    if (keepNames) {
821      unsigned int maxLength=0;
822      int iRow;
823      rowNames_.reserve(numberRows_);
824      for (iRow=0;iRow<numberRows_;iRow++) {
825        const char * name = m.rowName(iRow);
826        maxLength = max(maxLength,(unsigned int) strlen(name));
827          rowNames_.push_back(name);
828      }
829     
830      int iColumn;
831      columnNames_.reserve(numberColumns_);
832      for (iColumn=0;iColumn<numberColumns_;iColumn++) {
833        const char * name = m.columnName(iColumn);
834        maxLength = max(maxLength,(unsigned int) strlen(name));
835        columnNames_.push_back(name);
836      }
837      lengthNames_=(int) maxLength;
838    } else {
839      lengthNames_=0;
840    }
841    setDblParam(ClpObjOffset,m.objectiveOffset());
842    time2 = cpuTime();
843    handler_->message(CLP_IMPORT_RESULT,messages_)
844      <<fileName
845      <<time2-time1<<CoinMessageEol;
846  } else {
847    // errors
848    handler_->message(CLP_IMPORT_ERRORS,messages_)
849      <<status<<fileName<<CoinMessageEol;
850  }
851
852  return status;
853}
854bool ClpModel::isPrimalObjectiveLimitReached() const
855{
856  double limit = 0.0;
857  getDblParam(ClpPrimalObjectiveLimit, limit);
858  if (limit > 1e30) {
859    // was not ever set
860    return false;
861  }
862   
863  const double obj = objectiveValue();
864  const int maxmin = optimizationDirection();
865
866  if (problemStatus_ == 0) // optimal
867    return maxmin > 0 ? (obj < limit) /*minim*/ : (obj > limit) /*maxim*/;
868  else if (problemStatus_==2)
869    return true;
870  else
871    return false;
872}
873
874bool ClpModel::isDualObjectiveLimitReached() const
875{
876
877  double limit = 0.0;
878  getDblParam(ClpDualObjectiveLimit, limit);
879  if (limit > 1e30) {
880    // was not ever set
881    return false;
882  }
883   
884  const double obj = objectiveValue();
885  const int maxmin = optimizationDirection();
886
887  if (problemStatus_ == 0) // optimal
888    return maxmin > 0 ? (obj > limit) /*minim*/ : (obj < limit) /*maxim*/;
889  else if (problemStatus_==1)
890    return true;
891  else
892    return false;
893
894}
895void 
896ClpModel::copyInIntegerInformation(const char * information)
897{
898  delete [] integerType_;
899  if (information) {
900    integerType_ = new char[numberColumns_];
901    memcpy(integerType_,information,numberColumns_*sizeof(char));
902  } else {
903    integerType_ = NULL;
904  }
905}
906// Drops names - makes lengthnames 0 and names empty
907void 
908ClpModel::dropNames()
909{
910  lengthNames_=0;
911  rowNames_ = std::vector<std::string> ();
912  columnNames_ = std::vector<std::string> ();
913}
914// Drop integer informations
915void 
916ClpModel::deleteIntegerInformation()
917{
918  delete [] integerType_;
919  integerType_ = NULL;
920}
921/* Return copy of status array (char[numberRows+numberColumns]),
922   use delete [] */
923unsigned char * 
924ClpModel::statusCopy() const
925{
926  return ClpCopyOfArray(status_,numberRows_+numberColumns_);
927}
928// Copy in status vector
929void 
930ClpModel::copyinStatus(const unsigned char * statusArray)
931{
932  delete [] status_;
933  if (statusArray) {
934    status_ = new unsigned char [numberRows_+numberColumns_];
935    memcpy(status_,statusArray,(numberRows_+numberColumns_)*sizeof(unsigned char));
936  } else {
937    status_=NULL;
938  }
939}
Note: See TracBrowser for help on using the repository browser.