Ignore:
Timestamp:
Apr 28, 2008 11:38:45 AM (13 years ago)
Author:
forrest
Message:

many changes to try and improve performance

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/ClpModel.cpp

    r1185 r1197  
    6767  rowScale_(NULL),
    6868  columnScale_(NULL),
     69  inverseRowScale_(NULL),
     70  inverseColumnScale_(NULL),
    6971  scalingFlag_(3),
    7072  status_(NULL),
     
    8890  maximumColumns_(-1),
    8991  maximumRows_(-1),
     92  maximumInternalColumns_(-1),
     93  maximumInternalRows_(-1),
    9094  savedRowScale_(NULL),
    9195  savedColumnScale_(NULL)
     
    645649  maximumColumns_(-1),
    646650  maximumRows_(-1),
     651  maximumInternalColumns_(-1),
     652  maximumInternalRows_(-1),
    647653  savedRowScale_(NULL),
    648654  savedColumnScale_(NULL)
     
    807813    } else {
    808814      // This already has arrays - just copy
     815      savedRowScale_ = NULL;
     816      savedColumnScale_ = NULL;
    809817      startPermanentArrays();
    810818      if (rhs.integerType_) {
     
    868876        assert (savedRowScale_);
    869877        assert (!rowScale_);
    870         ClpDisjointCopyN(rhs.savedRowScale_,2*maximumRows_,savedRowScale_);
    871         ClpDisjointCopyN(rhs.savedColumnScale_,2*maximumColumns_,savedColumnScale_);
     878        ClpDisjointCopyN(rhs.savedRowScale_,4*maximumInternalRows_,savedRowScale_);
     879        ClpDisjointCopyN(rhs.savedColumnScale_,4*maximumInternalColumns_,savedColumnScale_);
    872880      } else {
    873881        assert (!savedRowScale_);
     
    884892  } else {
    885893    savedRowScale_ = rhs.savedRowScale_;
     894    assert (!savedRowScale_);
    886895    savedColumnScale_ = rhs.savedColumnScale_;
    887896    rowActivity_ = rhs.rowActivity_;
     
    910919    status_ = rhs.status_;
    911920  }
     921  inverseRowScale_ = NULL;
     922  inverseColumnScale_ = NULL;
    912923}
    913924// Copy contents - resizing if necessary - otherwise re-use memory
     
    925936  }
    926937#if 0
    927     delete modelPtr_->matrix_;
    928     if (continuousModel_->matrix_) {
    929       modelPtr_->matrix_ = continuousModel_->matrix_->clone();
    930     } else {
    931       modelPtr_->matrix_=NULL;
    932     }
     938  delete modelPtr_->matrix_;
     939  if (continuousModel_->matrix_) {
     940    modelPtr_->matrix_ = continuousModel_->matrix_->clone();
     941  } else {
     942    modelPtr_->matrix_=NULL;
     943  }
    933944#endif
    934945}
     
    959970  savedRowScale_=NULL;
    960971  savedColumnScale_=NULL;
     972  inverseRowScale_ = NULL;
     973  inverseColumnScale_ = NULL;
    961974}
    962975// Return model - nulls all arrays so can be deleted safely
     
    10031016    handler_ = NULL;
    10041017  }
     1018  inverseRowScale_ = NULL;
     1019  inverseColumnScale_ = NULL;
    10051020}
    10061021//#############################################################################
     
    12061221    return; // nothing to do
    12071222  whatsChanged_ = 0;
    1208   rowActivity_ = resizeDouble(rowActivity_,numberRows_,
    1209                               newNumberRows,0.0,true);
    1210   dual_ = resizeDouble(dual_,numberRows_,
    1211                        newNumberRows,0.0,true);
    1212   rowObjective_ = resizeDouble(rowObjective_,numberRows_,
    1213                                newNumberRows,0.0,false);
    1214   rowLower_ = resizeDouble(rowLower_,numberRows_,
    1215                            newNumberRows,-COIN_DBL_MAX,true);
    1216   rowUpper_ = resizeDouble(rowUpper_,numberRows_,
    1217                            newNumberRows,COIN_DBL_MAX,true);
    1218   columnActivity_ = resizeDouble(columnActivity_,numberColumns_,
    1219                                  newNumberColumns,0.0,true);
    1220   reducedCost_ = resizeDouble(reducedCost_,numberColumns_,
    1221                               newNumberColumns,0.0,true);
    1222   savedRowScale_ = resizeDouble(savedRowScale_,2*numberRows_,
    1223                            2*newNumberRows,-COIN_DBL_MAX,false);
    1224   savedColumnScale_ = resizeDouble(savedColumnScale_,2*numberColumns_,
    1225                            2*newNumberColumns,-COIN_DBL_MAX,false);
    1226   if (objective_)
     1223  int numberRows2=newNumberRows;
     1224  int numberColumns2=newNumberColumns;
     1225  if (numberRows2<maximumRows_)
     1226    numberRows2=maximumRows_;
     1227  if (numberColumns2<maximumColumns_)
     1228    numberColumns2=maximumColumns_;
     1229  if (numberRows2>maximumRows_) {
     1230    rowActivity_ = resizeDouble(rowActivity_,numberRows_,
     1231                                newNumberRows,0.0,true);
     1232    dual_ = resizeDouble(dual_,numberRows_,
     1233                         newNumberRows,0.0,true);
     1234    rowObjective_ = resizeDouble(rowObjective_,numberRows_,
     1235                                 newNumberRows,0.0,false);
     1236    rowLower_ = resizeDouble(rowLower_,numberRows_,
     1237                             newNumberRows,-COIN_DBL_MAX,true);
     1238    rowUpper_ = resizeDouble(rowUpper_,numberRows_,
     1239                             newNumberRows,COIN_DBL_MAX,true);
     1240  }
     1241  if (numberColumns2>maximumColumns_) {
     1242    columnActivity_ = resizeDouble(columnActivity_,numberColumns_,
     1243                                   newNumberColumns,0.0,true);
     1244    reducedCost_ = resizeDouble(reducedCost_,numberColumns_,
     1245                                newNumberColumns,0.0,true);
     1246  }
     1247  if (savedRowScale_&&numberRows2>maximumInternalRows_) {
     1248    double * temp;
     1249    temp = new double [4*newNumberRows];
     1250    CoinFillN(temp,4*newNumberRows,1.0);
     1251    CoinMemcpyN(savedRowScale_,numberRows_,temp);
     1252    CoinMemcpyN(savedRowScale_+maximumInternalRows_,numberRows_,temp+newNumberRows);
     1253    CoinMemcpyN(savedRowScale_+2*maximumInternalRows_,numberRows_,temp+2*newNumberRows);
     1254    CoinMemcpyN(savedRowScale_+3*maximumInternalRows_,numberRows_,temp+3*newNumberRows);
     1255    delete [] savedRowScale_;
     1256    savedRowScale_ = temp;
     1257  }
     1258  if (savedColumnScale_&&numberColumns2>maximumInternalColumns_) {
     1259    double * temp;
     1260    temp = new double [4*newNumberColumns];
     1261    CoinFillN(temp,4*newNumberColumns,1.0);
     1262    CoinMemcpyN(savedColumnScale_,numberColumns_,temp);
     1263    CoinMemcpyN(savedColumnScale_+maximumInternalColumns_,numberColumns_,temp+newNumberColumns);
     1264    CoinMemcpyN(savedColumnScale_+2*maximumInternalColumns_,numberColumns_,temp+2*newNumberColumns);
     1265    CoinMemcpyN(savedColumnScale_+3*maximumInternalColumns_,numberColumns_,temp+3*newNumberColumns);
     1266    delete [] savedColumnScale_;
     1267    savedColumnScale_ = temp;
     1268  }
     1269  if (objective_&&numberColumns2>maximumColumns_)
    12271270    objective_->resize(newNumberColumns);
    1228   else
     1271  else if (!objective_)
    12291272    objective_ = new ClpLinearObjective(NULL,newNumberColumns);
    1230   columnLower_ = resizeDouble(columnLower_,numberColumns_,
    1231                               newNumberColumns,0.0,true);
    1232   columnUpper_ = resizeDouble(columnUpper_,numberColumns_,
    1233                               newNumberColumns,COIN_DBL_MAX,true);
     1273  if (numberColumns2>maximumColumns_) {
     1274    columnLower_ = resizeDouble(columnLower_,numberColumns_,
     1275                                newNumberColumns,0.0,true);
     1276    columnUpper_ = resizeDouble(columnUpper_,numberColumns_,
     1277                                newNumberColumns,COIN_DBL_MAX,true);
     1278  }
    12341279  if (newNumberRows<numberRows_) {
    12351280    int * which = new int[numberRows_-newNumberRows];
     
    12511296  if (status_) {
    12521297    if (newNumberColumns+newNumberRows) {
    1253       unsigned char * tempC = new unsigned char [newNumberColumns+newNumberRows];
    1254       unsigned char * tempR = tempC + newNumberColumns;
    1255       memset(tempC,3,newNumberColumns*sizeof(unsigned char));
    1256       memset(tempR,1,newNumberRows*sizeof(unsigned char));
    1257       memcpy(tempC,status_,CoinMin(newNumberColumns,numberColumns_)*sizeof(unsigned char));
    1258       memcpy(tempR,status_+numberColumns_,CoinMin(newNumberRows,numberRows_)*sizeof(unsigned char));
    1259       delete [] status_;
    1260       status_ = tempC;
     1298      if (newNumberColumns+newNumberRows>maximumRows_+maximumColumns_) {
     1299        unsigned char * tempC = new unsigned char [newNumberColumns+newNumberRows];
     1300        unsigned char * tempR = tempC + newNumberColumns;
     1301        memset(tempC,3,newNumberColumns*sizeof(unsigned char));
     1302        memset(tempR,1,newNumberRows*sizeof(unsigned char));
     1303        CoinMemcpyN(status_,CoinMin(newNumberColumns,numberColumns_),tempC);
     1304        CoinMemcpyN(status_+numberColumns_,CoinMin(newNumberRows,numberRows_),tempR);
     1305        delete [] status_;
     1306        status_ = tempC;
     1307      } else if (newNumberColumns<numberColumns_) {
     1308        memmove(status_+newNumberColumns,status_+numberColumns_,
     1309                newNumberRows);
     1310      } else if (newNumberColumns>numberColumns_) {
     1311        memset(status_+numberColumns_,3,newNumberColumns-numberColumns_);
     1312        memmove(status_+newNumberColumns,status_+numberColumns_,
     1313                newNumberRows);
     1314      }
    12611315    } else {
    12621316      // empty model - some systems don't like new [0]
     
    12971351    delete [] which;
    12981352  }
    1299   if (integerType_) {
     1353  if (integerType_&&numberColumns2>maximumColumns_) {
    13001354    char * temp = new char [newNumberColumns];
    13011355    CoinZeroN(temp,newNumberColumns);
     
    13061360  }
    13071361  numberColumns_ = newNumberColumns;
     1362  if ((specialOptions_&65536)!=0) {
     1363    // leave until next create rim to up numbers
     1364  }
     1365  if (maximumRows_>=0) {
     1366    if (numberRows_>maximumRows_)
     1367      printf("resize %d rows, %d old maximum rows\n",
     1368             numberRows_,maximumRows_);
     1369    maximumRows_ = CoinMax(maximumRows_,numberRows_);
     1370    maximumColumns_ = CoinMax(maximumColumns_,numberColumns_);
     1371  }
    13081372}
    13091373// Deletes rows
     
    13151379  whatsChanged_ &= ~(1+2+4+8+16+32); // all except columns changed
    13161380  int newSize=0;
    1317   rowActivity_ = deleteDouble(rowActivity_,numberRows_,
    1318                               number, which, newSize);
    1319   dual_ = deleteDouble(dual_,numberRows_,
    1320                               number, which, newSize);
    1321   rowObjective_ = deleteDouble(rowObjective_,numberRows_,
    1322                               number, which, newSize);
    1323   rowLower_ = deleteDouble(rowLower_,numberRows_,
    1324                               number, which, newSize);
    1325   rowUpper_ = deleteDouble(rowUpper_,numberRows_,
    1326                               number, which, newSize);
    1327   if (matrix_->getNumRows())
    1328     matrix_->deleteRows(number,which);
    1329   //matrix_->removeGaps();
    1330   // status
    1331   if (status_) {
    1332     if (numberColumns_+newSize) {
    1333       unsigned char * tempR  = (unsigned char *) deleteChar((char *)status_+numberColumns_,
    1334                                                             numberRows_,
    1335                                                             number, which, newSize,false);
    1336       unsigned char * tempC = new unsigned char [numberColumns_+newSize];
    1337       memcpy(tempC,status_,numberColumns_*sizeof(unsigned char));
    1338       memcpy(tempC+numberColumns_,tempR,newSize*sizeof(unsigned char));
    1339       delete [] tempR;
    1340       delete [] status_;
    1341       status_ = tempC;
    1342     } else {
    1343       // empty model - some systems don't like new [0]
    1344       delete [] status_;
    1345       status_ = NULL;
    1346     }
     1381  if (maximumRows_<0) {
     1382    rowActivity_ = deleteDouble(rowActivity_,numberRows_,
     1383                                number, which, newSize);
     1384    dual_ = deleteDouble(dual_,numberRows_,
     1385                         number, which, newSize);
     1386    rowObjective_ = deleteDouble(rowObjective_,numberRows_,
     1387                                 number, which, newSize);
     1388    rowLower_ = deleteDouble(rowLower_,numberRows_,
     1389                             number, which, newSize);
     1390    rowUpper_ = deleteDouble(rowUpper_,numberRows_,
     1391                             number, which, newSize);
     1392    if (matrix_->getNumRows())
     1393      matrix_->deleteRows(number,which);
     1394    //matrix_->removeGaps();
     1395    // status
     1396    if (status_) {
     1397      if (numberColumns_+newSize) {
     1398        unsigned char * tempR  = (unsigned char *) deleteChar((char *)status_+numberColumns_,
     1399                                                              numberRows_,
     1400                                                              number, which, newSize,false);
     1401        unsigned char * tempC = new unsigned char [numberColumns_+newSize];
     1402        CoinMemcpyN(status_,numberColumns_,tempC);
     1403        CoinMemcpyN(tempR,newSize,tempC+numberColumns_);
     1404        delete [] tempR;
     1405        delete [] status_;
     1406        status_ = tempC;
     1407      } else {
     1408        // empty model - some systems don't like new [0]
     1409        delete [] status_;
     1410        status_ = NULL;
     1411      }
     1412    }
     1413  } else {
     1414    char * deleted = new char [numberRows_];
     1415    int i;
     1416    int numberDeleted=0;
     1417    CoinZeroN(deleted,numberRows_);
     1418    for (i=0;i<number;i++) {
     1419      int j = which[i];
     1420      if (j>=0&&j<numberRows_&&!deleted[j]) {
     1421        numberDeleted++;
     1422        deleted[j]=1;
     1423      }
     1424    }
     1425    assert (!rowObjective_);
     1426    unsigned char * status2 = status_+numberColumns_;
     1427    for (i=0;i<numberRows_;i++) {
     1428      if (!deleted[i]) {
     1429        rowActivity_[newSize]=rowActivity_[i];
     1430        dual_[newSize] = dual_[i];
     1431        rowLower_[newSize] = rowLower_[i];
     1432        rowUpper_[newSize] = rowUpper_[i];
     1433        status2[newSize] = status2[i];
     1434        newSize++;
     1435      }
     1436    }
     1437    if (matrix_->getNumRows())
     1438      matrix_->deleteRows(number,which);
     1439    //matrix_->removeGaps();
     1440    delete [] deleted;
    13471441  }
    13481442#ifndef CLP_NO_STD
     
    13821476  if (!number)
    13831477    return; // nothing to do
     1478  assert (maximumColumns_<0);
    13841479  whatsChanged_ &= ~(1+2+4+8+64+128+256); // all except rows changed
    13851480  int newSize=0;
     
    14151510                                                            number, which, newSize,false);
    14161511      unsigned char * temp = new unsigned char [numberRows_+newSize];
    1417       memcpy(temp,tempC,newSize*sizeof(unsigned char));
    1418       memcpy(temp+newSize,status_+numberColumns_,
    1419              numberRows_*sizeof(unsigned char));
     1512      CoinMemcpyN(tempC,newSize,temp);
     1513      CoinMemcpyN(status_+numberColumns_,       numberRows_,temp+newSize);
    14201514      delete [] tempC;
    14211515      delete [] status_;
     
    25262620  if (problemStatus_==3) {
    25272621    secondaryStatus_=0;
    2528     if (CoinCpuTime()>=dblParam_[ClpMaxSeconds])
     2622    if (CoinCpuTime()>=dblParam_[ClpMaxSeconds]&&dblParam_[ClpMaxSeconds]>=0.0)
    25292623      secondaryStatus_=9;
    25302624  }
     
    28742968  if (statusArray) {
    28752969    status_ = new unsigned char [numberRows_+numberColumns_];
    2876     memcpy(status_,statusArray,(numberRows_+numberColumns_)*sizeof(unsigned char));
     2970    CoinMemcpyN(statusArray,(numberRows_+numberColumns_),status_);
    28772971  } else {
    28782972    status_=NULL;
     
    29803074  maximumColumns_(-1),
    29813075  maximumRows_(-1),
     3076  maximumInternalColumns_(-1),
     3077  maximumInternalRows_(-1),
    29823078  savedRowScale_(NULL),
    29833079  savedColumnScale_(NULL)
     
    29943090  maximumColumns_ = -1;
    29953091  maximumRows_ = -1;
     3092  maximumInternalColumns_ = -1;
     3093  maximumInternalRows_ = -1;
    29963094  savedRowScale_ = NULL;
    29973095  savedColumnScale_ = NULL;
     
    31063204  rowScale_ = NULL;
    31073205  columnScale_ = NULL;
     3206  inverseRowScale_ = NULL;
     3207  inverseColumnScale_ = NULL;
    31083208  scalingFlag_ = rhs->scalingFlag_;
    31093209  rowCopy_=NULL;
     
    33143414{
    33153415  secondaryStatus_=6; // so user can see something odd
    3316   // May be in middle of expecting bounds to stay same etc - negate expectations
    3317   whatsChanged_=0;
    33183416  if (printMessage)
    33193417    handler_->message(CLP_EMPTY_PROBLEM,messages_)
     
    37893887ClpModel::startPermanentArrays()
    37903888{
     3889  printf("startperm a %d rows, %d maximum rows\n",
     3890         numberRows_,maximumRows_);
    37913891  if ((specialOptions_&65536)!=0) {
    37923892    if (numberRows_>maximumRows_||numberColumns_>maximumColumns_) {
    37933893      if (numberRows_>maximumRows_)
    3794         maximumRows_ = numberRows_+10+numberRows_/100;
     3894        if (maximumRows_>0)
     3895          maximumRows_ = numberRows_+10+numberRows_/100;
     3896        else
     3897          maximumRows_ = numberRows_;
    37953898      if (numberColumns_>maximumColumns_)
    3796         maximumColumns_ = numberColumns_+10+numberColumns_/100;
     3899        if (maximumColumns_>0)
     3900          maximumColumns_ = numberColumns_+10+numberColumns_/100;
     3901        else
     3902          maximumColumns_ = numberColumns_;
    37973903      // need to make sure numberRows_ OK and size of matrices
    37983904      resize(maximumRows_,maximumColumns_);
     3905      printf("startperm b %d rows, %d maximum rows\n",
     3906             numberRows_,maximumRows_);
    37993907    } else {
    38003908      return;
     
    38043912    maximumRows_ = numberRows_;
    38053913    maximumColumns_ = numberColumns_;
     3914    baseMatrix_ = *matrix();
     3915    baseMatrix_.cleanMatrix();
     3916    baseRowCopy_.setExtraGap(0.0);
     3917    baseRowCopy_.setExtraMajor(0.0);
     3918    baseRowCopy_.reverseOrderedCopyOf(baseMatrix_);
     3919    printf("startperm c %d rows, %d maximum rows\n",
     3920             numberRows_,maximumRows_);
    38063921  }
    38073922}
     
    40024117      }
    40034118    }
     4119#ifndef NDEBUG
    40044120    for (iRow=0;iRow<numberIn;iRow++) {
    40054121      int kRow = eligible[iRow];
    40064122      assert (rotate[kRow]>=2);
    40074123    }
     4124#endif
    40084125    trueNetwork=true;
    40094126    for (iColumn=0;iColumn<numberColumns_;iColumn++) {
Note: See TracChangeset for help on using the changeset viewer.