Ignore:
Timestamp:
Jan 2, 2008 5:14:29 AM (13 years ago)
Author:
forrest
Message:

changes to try and make faster

File:
1 edited

Legend:

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

    r1141 r1147  
    8080  defaultHandler_(true),
    8181  rowNames_(),
    82   columnNames_()
     82  columnNames_(),
    8383#else
    84   defaultHandler_(true)
    85 #endif
     84  defaultHandler_(true),
     85#endif
     86  maximumColumns_(-1),
     87  maximumRows_(-1),
     88  savedRowScale_(NULL),
     89  savedColumnScale_(NULL)
    8690{
    8791  intParam_[ClpMaxNumIteration] = 2147483647;
     
    118122    handler_ = NULL;
    119123  }
    120   gutsOfDelete();
    121 }
    122 void ClpModel::gutsOfDelete()
    123 {
    124   delete [] rowActivity_;
    125   rowActivity_=NULL;
    126   delete [] columnActivity_;
    127   columnActivity_=NULL;
    128   delete [] dual_;
    129   dual_=NULL;
    130   delete [] reducedCost_;
    131   reducedCost_=NULL;
    132   delete [] rowLower_;
    133   delete [] rowUpper_;
    134   delete [] rowObjective_;
    135   rowLower_=NULL;
    136   rowUpper_=NULL;
    137   rowObjective_=NULL;
    138   delete [] columnLower_;
    139   delete [] columnUpper_;
    140   delete objective_;
    141   columnLower_=NULL;
    142   columnUpper_=NULL;
    143   objective_=NULL;
     124  gutsOfDelete(0);
     125}
     126// Does most of deletion (0 = all, 1 = most)
     127void
     128ClpModel::gutsOfDelete(int type)
     129{
     130  if (!type||!permanentArrays()) {
     131    maximumRows_=-1;
     132    maximumColumns_ = -1;
     133    delete [] rowActivity_;
     134    rowActivity_=NULL;
     135    delete [] columnActivity_;
     136    columnActivity_=NULL;
     137    delete [] dual_;
     138    dual_=NULL;
     139    delete [] reducedCost_;
     140    reducedCost_=NULL;
     141    delete [] rowLower_;
     142    delete [] rowUpper_;
     143    delete [] rowObjective_;
     144    rowLower_=NULL;
     145    rowUpper_=NULL;
     146    rowObjective_=NULL;
     147    delete [] columnLower_;
     148    delete [] columnUpper_;
     149    delete objective_;
     150    columnLower_=NULL;
     151    columnUpper_=NULL;
     152    objective_=NULL;
     153    delete [] savedRowScale_;
     154    if (rowScale_==savedRowScale_)
     155      rowScale_=NULL;
     156    savedRowScale_ = NULL;
     157    delete [] savedColumnScale_;
     158    if (columnScale_==savedColumnScale_)
     159      columnScale_=NULL;
     160    savedColumnScale_ = NULL;
     161    delete [] rowScale_;
     162    rowScale_ = NULL;
     163    delete [] columnScale_;
     164    columnScale_ = NULL;
     165    delete [] integerType_;
     166    integerType_ = NULL;
     167    delete [] status_;
     168    status_=NULL;
     169    delete eventHandler_;
     170    eventHandler_=NULL;
     171  }
     172  whatsChanged_=0;
    144173  delete matrix_;
    145174  matrix_=NULL;
     
    148177  delete [] ray_;
    149178  ray_ = NULL;
    150   delete [] rowScale_;
    151   rowScale_ = NULL;
    152   delete [] columnScale_;
    153   columnScale_ = NULL;
    154   delete [] integerType_;
    155   integerType_ = NULL;
    156   delete [] status_;
    157   status_=NULL;
    158   delete eventHandler_;
    159   eventHandler_=NULL;
    160   whatsChanged_=0;
    161179  specialOptions_ = 0;
     180}
     181void
     182ClpModel::setRowScale(double * scale)
     183{
     184  if (!savedRowScale_) {
     185    delete [] (double *) rowScale_;
     186    rowScale_ = scale;
     187  } else {
     188    assert (!scale);
     189    rowScale_ = NULL;
     190  }
     191}
     192void
     193ClpModel::setColumnScale(double * scale)
     194{
     195  if (!savedColumnScale_) {
     196    delete [] (double *) columnScale_;
     197    columnScale_ = scale;
     198  } else {
     199    assert (!scale);
     200    columnScale_ = NULL;
     201  }
    162202}
    163203//#############################################################################
     
    187227  // Save specialOptions
    188228  int saveOptions = specialOptions_;
    189   gutsOfDelete();
     229  gutsOfDelete(0);
    190230  specialOptions_ = saveOptions;
    191231  eventHandler_ = handler;
     
    597637  optimizationDirection_(rhs.optimizationDirection_),
    598638  numberRows_(rhs.numberRows_),
    599   numberColumns_(rhs.numberColumns_)
     639  numberColumns_(rhs.numberColumns_),
     640  specialOptions_(rhs.specialOptions_),
     641  maximumColumns_(-1),
     642  maximumRows_(-1),
     643  savedRowScale_(NULL),
     644  savedColumnScale_(NULL)
    600645{
    601646  gutsOfCopy(rhs);
     
    604649    // really do scaling
    605650    scalingFlag_=scalingMode;
    606     delete [] rowScale_;
    607     rowScale_ = NULL;
    608     delete [] columnScale_;
    609     columnScale_ = NULL;
     651    setRowScale(NULL);
     652    setColumnScale(NULL);
    610653    delete rowCopy_; // in case odd
    611654    rowCopy_=NULL;
     
    628671  if (this != &rhs) {
    629672    if (defaultHandler_) {
    630       delete handler_;
    631       handler_ = NULL;
    632     }
    633     gutsOfDelete();
     673      //delete handler_;
     674      //handler_ = NULL;
     675    }
     676    gutsOfDelete(1);
    634677    optimizationDirection_ = rhs.optimizationDirection_;
    635678    numberRows_ = rhs.numberRows_;
    636679    numberColumns_ = rhs.numberColumns_;
    637     gutsOfCopy(rhs);
     680    gutsOfCopy(rhs,-1);
    638681  }
    639682  return *this;
    640683}
    641 // Does most of copying
    642 void
    643 ClpModel::gutsOfCopy(const ClpModel & rhs, bool trueCopy)
     684/* Does most of copying
     685   If trueCopy 0 then just points to arrays
     686   If -1 leaves as much as possible */
     687void
     688ClpModel::gutsOfCopy(const ClpModel & rhs, int trueCopy)
    644689{
    645690  defaultHandler_ = rhs.defaultHandler_;
    646   if (defaultHandler_)
    647     handler_ = new CoinMessageHandler(*rhs.handler_);
    648    else
    649     handler_ = rhs.handler_;
    650   eventHandler_ = rhs.eventHandler_->clone();
    651   randomNumberGenerator_ = rhs.randomNumberGenerator_;
    652   messages_ = rhs.messages_;
    653   coinMessages_ = rhs.coinMessages_;
     691  if (trueCopy>=0) {
     692    if (defaultHandler_)
     693      handler_ = new CoinMessageHandler(*rhs.handler_);
     694    else
     695      handler_ = rhs.handler_;
     696    eventHandler_ = rhs.eventHandler_->clone();
     697    randomNumberGenerator_ = rhs.randomNumberGenerator_;
     698    messages_ = rhs.messages_;
     699    coinMessages_ = rhs.coinMessages_;
     700  } else {
     701    if (!eventHandler_&&rhs.eventHandler_)
     702      eventHandler_ = rhs.eventHandler_->clone();
     703  }
    654704  intParam_[ClpMaxNumIteration] = rhs.intParam_[ClpMaxNumIteration];
    655705  intParam_[ClpMaxNumIterationHotStart] =
     
    693743#endif
    694744    numberThreads_ = rhs.numberThreads_;
    695     integerType_ = CoinCopyOfArray(rhs.integerType_,numberColumns_);
    696     if (rhs.rowActivity_) {
    697       rowActivity_=new double[numberRows_];
    698       columnActivity_=new double[numberColumns_];
    699       dual_=new double[numberRows_];
    700       reducedCost_=new double[numberColumns_];
    701       ClpDisjointCopyN ( rhs.rowActivity_, numberRows_ ,
    702                           rowActivity_);
    703       ClpDisjointCopyN ( rhs.columnActivity_, numberColumns_ ,
    704                           columnActivity_);
    705       ClpDisjointCopyN ( rhs.dual_, numberRows_ ,
    706                           dual_);
    707       ClpDisjointCopyN ( rhs.reducedCost_, numberColumns_ ,
    708                           reducedCost_);
     745    if (maximumRows_<0) {
     746      specialOptions_ &= ~65536;
     747      savedRowScale_ = NULL;
     748      savedColumnScale_ = NULL;
     749      integerType_ = CoinCopyOfArray(rhs.integerType_,numberColumns_);
     750      if (rhs.rowActivity_) {
     751        rowActivity_=new double[numberRows_];
     752        columnActivity_=new double[numberColumns_];
     753        dual_=new double[numberRows_];
     754        reducedCost_=new double[numberColumns_];
     755        ClpDisjointCopyN ( rhs.rowActivity_, numberRows_ ,
     756                           rowActivity_);
     757        ClpDisjointCopyN ( rhs.columnActivity_, numberColumns_ ,
     758                           columnActivity_);
     759        ClpDisjointCopyN ( rhs.dual_, numberRows_ ,
     760                           dual_);
     761        ClpDisjointCopyN ( rhs.reducedCost_, numberColumns_ ,
     762                           reducedCost_);
     763      } else {
     764        rowActivity_=NULL;
     765        columnActivity_=NULL;
     766        dual_=NULL;
     767        reducedCost_=NULL;
     768      }
     769      rowLower_ = ClpCopyOfArray ( rhs.rowLower_, numberRows_ );
     770      rowUpper_ = ClpCopyOfArray ( rhs.rowUpper_, numberRows_ );
     771      columnLower_ = ClpCopyOfArray ( rhs.columnLower_, numberColumns_ );
     772      int scaleLength = ((specialOptions_&131072)==0) ? 1 : 2;
     773      columnUpper_ = ClpCopyOfArray ( rhs.columnUpper_, numberColumns_ );
     774      rowScale_ = ClpCopyOfArray(rhs.rowScale_,numberRows_*scaleLength);
     775      columnScale_ = ClpCopyOfArray(rhs.columnScale_,numberColumns_*scaleLength);
     776      if (rhs.objective_)
     777        objective_  = rhs.objective_->clone();
     778      else
     779        objective_ = NULL;
     780      rowObjective_ = ClpCopyOfArray ( rhs.rowObjective_, numberRows_ );
     781      status_ = ClpCopyOfArray( rhs.status_,numberColumns_+numberRows_);
     782      ray_ = NULL;
     783      if (problemStatus_==1&&!secondaryStatus_)
     784        ray_ = ClpCopyOfArray (rhs.ray_,numberRows_);
     785      else if (problemStatus_==2)
     786        ray_ = ClpCopyOfArray (rhs.ray_,numberColumns_);
     787      if (rhs.rowCopy_) {
     788        rowCopy_ = rhs.rowCopy_->clone();
     789      } else {
     790        rowCopy_=NULL;
     791      }
     792      matrix_=NULL;
     793      if (rhs.matrix_) {
     794        matrix_ = rhs.matrix_->clone();
     795      }
    709796    } else {
    710       rowActivity_=NULL;
    711       columnActivity_=NULL;
    712       dual_=NULL;
    713       reducedCost_=NULL;
    714     }
    715     rowLower_ = ClpCopyOfArray ( rhs.rowLower_, numberRows_ );
    716     rowUpper_ = ClpCopyOfArray ( rhs.rowUpper_, numberRows_ );
    717     columnLower_ = ClpCopyOfArray ( rhs.columnLower_, numberColumns_ );
    718     int scaleLength = ((specialOptions_&131072)==0) ? 1 : 2;
    719     columnUpper_ = ClpCopyOfArray ( rhs.columnUpper_, numberColumns_ );
    720     rowScale_ = ClpCopyOfArray(rhs.rowScale_,numberRows_*scaleLength);
    721     columnScale_ = ClpCopyOfArray(rhs.columnScale_,numberColumns_*scaleLength);
    722     if (rhs.objective_)
    723       objective_  = rhs.objective_->clone();
    724     else
    725       objective_ = NULL;
    726     rowObjective_ = ClpCopyOfArray ( rhs.rowObjective_, numberRows_ );
    727     status_ = ClpCopyOfArray( rhs.status_,numberColumns_+numberRows_);
    728     ray_ = NULL;
    729     if (problemStatus_==1&&!secondaryStatus_)
    730       ray_ = ClpCopyOfArray (rhs.ray_,numberRows_);
    731     else if (problemStatus_==2)
    732       ray_ = ClpCopyOfArray (rhs.ray_,numberColumns_);
    733     if (rhs.rowCopy_) {
    734       rowCopy_ = rhs.rowCopy_->clone();
    735     } else {
    736       rowCopy_=NULL;
    737     }
    738     matrix_=NULL;
    739     if (rhs.matrix_) {
    740       matrix_ = rhs.matrix_->clone();
     797      // This already has arrays - just copy
     798      startPermanentArrays();
     799      if (rhs.integerType_) {
     800        assert (integerType_);
     801        ClpDisjointCopyN(rhs.integerType_,numberColumns_,integerType_);
     802      } else {
     803        integerType_ = NULL;
     804      }
     805      if (rhs.rowActivity_) {
     806        ClpDisjointCopyN ( rhs.rowActivity_, numberRows_ ,
     807                           rowActivity_);
     808        ClpDisjointCopyN ( rhs.columnActivity_, numberColumns_ ,
     809                           columnActivity_);
     810        ClpDisjointCopyN ( rhs.dual_, numberRows_ ,
     811                           dual_);
     812        ClpDisjointCopyN ( rhs.reducedCost_, numberColumns_ ,
     813                           reducedCost_);
     814      } else {
     815        rowActivity_=NULL;
     816        columnActivity_=NULL;
     817        dual_=NULL;
     818        reducedCost_=NULL;
     819      }
     820      ClpDisjointCopyN ( rhs.rowLower_, numberRows_,rowLower_ );
     821      ClpDisjointCopyN ( rhs.rowUpper_, numberRows_,rowUpper_ );
     822      ClpDisjointCopyN ( rhs.columnLower_, numberColumns_,columnLower_ );
     823      assert ((specialOptions_&131072)==0);
     824      ClpDisjointCopyN ( rhs.columnUpper_, numberColumns_,columnUpper_ );
     825      if (rhs.objective_) {
     826        abort(); //check if same
     827        objective_  = rhs.objective_->clone();
     828      } else {
     829        objective_ = NULL;
     830      }
     831      assert (!rhs.rowObjective_);
     832      ClpDisjointCopyN( rhs.status_,numberColumns_+numberRows_,status_);
     833      ray_ = NULL;
     834      if (problemStatus_==1&&!secondaryStatus_)
     835        ray_ = ClpCopyOfArray (rhs.ray_,numberRows_);
     836      else if (problemStatus_==2)
     837        ray_ = ClpCopyOfArray (rhs.ray_,numberColumns_);
     838      assert (!ray_);
     839      delete rowCopy_;
     840      if (rhs.rowCopy_) {
     841        rowCopy_ = rhs.rowCopy_->clone();
     842      } else {
     843        rowCopy_=NULL;
     844      }
     845      delete matrix_;
     846      matrix_=NULL;
     847      if (rhs.matrix_) {
     848        matrix_ = rhs.matrix_->clone();
     849      }
     850      if (rhs.savedRowScale_) {
     851        assert (savedRowScale_);
     852        assert (!rowScale_);
     853        ClpDisjointCopyN(rhs.savedRowScale_,2*maximumRows_,savedRowScale_);
     854        ClpDisjointCopyN(rhs.savedColumnScale_,2*maximumColumns_,savedColumnScale_);
     855      } else {
     856        assert (!savedRowScale_);
     857        if (rowScale_) {
     858          ClpDisjointCopyN(rhs.rowScale_,numberRows_,rowScale_);
     859          ClpDisjointCopyN(rhs.columnScale_,numberColumns_,columnScale_);
     860        } else {
     861          rowScale_ =NULL;
     862          columnScale_=NULL;
     863        }
     864      }
     865      abort(); // look at resizeDouble and resize
    741866    }
    742867  } else {
     868    savedRowScale_ = rhs.savedRowScale_;
     869    savedColumnScale_ = rhs.savedColumnScale_;
    743870    rowActivity_ = rhs.rowActivity_;
    744871    columnActivity_ = rhs.columnActivity_;
     
    766893  }
    767894}
     895// Copy contents - resizing if necessary - otherwise re-use memory
     896void
     897ClpModel::copy(const ClpMatrixBase * from, ClpMatrixBase * & to)
     898{
     899  assert (from);
     900  assert (to);
     901  const ClpPackedMatrix * matrixFrom = (dynamic_cast<const ClpPackedMatrix*>(from));
     902  ClpPackedMatrix * matrixTo = (dynamic_cast< ClpPackedMatrix*>(to));
     903  if (matrixFrom&&matrixTo) {
     904    matrixTo->copy(matrixFrom);
     905  } else {
     906    delete to;
     907    to =  from->clone();
     908  }
     909#if 0
     910    delete modelPtr_->matrix_;
     911    if (continuousModel_->matrix_) {
     912      modelPtr_->matrix_ = continuousModel_->matrix_->clone();
     913    } else {
     914      modelPtr_->matrix_=NULL;
     915    }
     916#endif
     917}
    768918/* Borrow model.  This is so we dont have to copy large amounts
    769919   of data around.  It assumes a derived class wants to overwrite
     
    776926    handler_ = NULL;
    777927  }
    778   gutsOfDelete();
     928  gutsOfDelete(1);
    779929  optimizationDirection_ = rhs.optimizationDirection_;
    780930  numberRows_ = rhs.numberRows_;
     
    782932  delete [] rhs.ray_;
    783933  rhs.ray_=NULL;
    784   gutsOfCopy(rhs,false);
     934  gutsOfCopy(rhs,0);
     935  specialOptions_ = rhs.specialOptions_ & ~65536;
     936  savedRowScale_=NULL;
     937  savedColumnScale_=NULL;
    785938}
    786939// Return model - nulls all arrays so can be deleted safely
     
    807960  otherModel.ray_ = ray_;
    808961  ray_ = NULL;
     962  rowScale_ = NULL;
     963  columnScale_ = NULL;
    809964  //rowScale_=NULL;
    810965  //columnScale_=NULL;
     
    9151070                      bool createArray)
    9161071{
    917   if ((array||createArray)&&size!=newSize) {
     1072  if ((array||createArray)&&size<newSize) {
    9181073    int i;
    9191074    double * newArray = new double[newSize];
     
    10361191  reducedCost_ = resizeDouble(reducedCost_,numberColumns_,
    10371192                              newNumberColumns,0.0,true);
     1193  savedRowScale_ = resizeDouble(savedRowScale_,2*numberRows_,
     1194                           2*newNumberRows,-COIN_DBL_MAX,false);
     1195  savedColumnScale_ = resizeDouble(savedColumnScale_,2*numberColumns_,
     1196                           2*newNumberColumns,-COIN_DBL_MAX,false);
    10381197  if (objective_)
    10391198    objective_->resize(newNumberColumns);
     
    10591218    ray_ = NULL;
    10601219  }
    1061   delete [] rowScale_;
    1062   rowScale_ = NULL;
    1063   delete [] columnScale_;
    1064   columnScale_ = NULL;
     1220  setRowScale(NULL);
     1221  setColumnScale(NULL);
    10651222  if (status_) {
    10661223    if (newNumberColumns+newNumberRows) {
     
    11831340  delete [] ray_;
    11841341  ray_ = NULL;
    1185   delete [] rowScale_;
     1342  if (savedRowScale_!=rowScale_) {
     1343    delete [] rowScale_;
     1344    delete [] columnScale_;
     1345  }
    11861346  rowScale_ = NULL;
    1187   delete [] columnScale_;
    11881347  columnScale_ = NULL;
    11891348}
     
    12641423  delete [] ray_;
    12651424  ray_ = NULL;
    1266   delete [] rowScale_;
    1267   rowScale_ = NULL;
    1268   delete [] columnScale_;
    1269   columnScale_ = NULL;
     1425  setRowScale(NULL);
     1426  setColumnScale(NULL);
    12701427}
    12711428// Add one row
     
    13231480    if (!matrix_)
    13241481      createEmptyMatrix();
    1325     delete [] rowScale_;
    1326     rowScale_ = NULL;
    1327     delete [] columnScale_;
    1328     columnScale_ = NULL;
     1482    setRowScale(NULL);
     1483    setColumnScale(NULL);
    13291484#ifndef CLP_NO_STD
    13301485    if (lengthNames_) {
     
    14151570  if (rows)
    14161571    matrix_->appendRows(number,rows);
    1417   delete [] rowScale_;
    1418   rowScale_ = NULL;
    1419   delete [] columnScale_;
    1420   columnScale_ = NULL;
     1572  setRowScale(NULL);
     1573  setColumnScale(NULL);
    14211574  if (lengthNames_) {
    14221575    rowNames_.resize(numberRows_);
     
    18041957    if (!matrix_)
    18051958      createEmptyMatrix();
    1806     delete [] rowScale_;
    1807     rowScale_ = NULL;
    1808     delete [] columnScale_;
    1809     columnScale_ = NULL;
     1959    setRowScale(NULL);
     1960    setColumnScale(NULL);
    18101961#ifndef CLP_NO_STD
    18111962    if (lengthNames_) {
     
    19082059  if (columns)
    19092060    matrix_->appendCols(number,columns);
    1910   delete [] rowScale_;
    1911   rowScale_ = NULL;
    1912   delete [] columnScale_;
    1913   columnScale_ = NULL;
     2061  setRowScale(NULL);
     2062  setColumnScale(NULL);
    19142063  if (lengthNames_) {
    19152064    columnNames_.resize(numberColumns_);
     
    27912940                     int numberColumns, const int * whichColumn,
    27922941                     bool dropNames, bool dropIntegers)
     2942  :  specialOptions_(rhs->specialOptions_),
     2943  maximumColumns_(-1),
     2944  maximumRows_(-1),
     2945  savedRowScale_(NULL),
     2946  savedColumnScale_(NULL)
    27932947{
    27942948  defaultHandler_ = rhs->defaultHandler_;
     
    28012955  messages_ = rhs->messages_;
    28022956  coinMessages_ = rhs->coinMessages_;
     2957  maximumColumns_ = -1;
     2958  maximumRows_ = -1;
     2959  savedRowScale_ = NULL;
     2960  savedColumnScale_ = NULL;
    28032961  intParam_[ClpMaxNumIteration] = rhs->intParam_[ClpMaxNumIteration];
    28042962  intParam_[ClpMaxNumIterationHotStart] =
     
    33943552  } else if (!mode) {
    33953553    scalingFlag_=0;
    3396     delete [] rowScale_;
    3397     rowScale_ = NULL;
    3398     delete [] columnScale_;
    3399     columnScale_ = NULL;
     3554    setRowScale(NULL);
     3555    setColumnScale(NULL);
    34003556  }
    34013557}
     
    34763632 
    34773633  scalingFlag_=0;
    3478   delete [] rowScale_;
    3479   rowScale_ = NULL;
    3480   delete [] columnScale_;
    3481   columnScale_ = NULL;
     3634  setRowScale(NULL);
     3635  setColumnScale(NULL);
    34823636}
    34833637void
     
    35823736  }
    35833737  return coinModel;
     3738}
     3739// Start or reset using maximumRows_ and Columns_
     3740void
     3741ClpModel::startPermanentArrays()
     3742{
     3743  if ((specialOptions_&65536)!=0) {
     3744    if (numberRows_>maximumRows_||numberColumns_>maximumColumns_) {
     3745      if (numberRows_>maximumRows_)
     3746        maximumRows_ = numberRows_+10+numberRows_/100;
     3747      if (numberColumns_>maximumColumns_)
     3748        maximumColumns_ = numberColumns_+10+numberColumns_/100;
     3749      // need to make sure numberRows_ OK and size of matrices
     3750      resize(maximumRows_,maximumColumns_);
     3751    } else {
     3752      return;
     3753    }
     3754  } else {
     3755    specialOptions_ |= 65536;
     3756    maximumRows_ = numberRows_;
     3757    maximumColumns_ = numberColumns_;
     3758  }
     3759}
     3760// Stop using maximumRows_ and Columns_
     3761void
     3762ClpModel::stopPermanentArrays()
     3763{
     3764  specialOptions_ &= ~65536;
     3765  maximumRows_=-1;
     3766  maximumColumns_=-1;
     3767  if (rowScale_!=savedRowScale_) {
     3768    delete [] savedRowScale_;
     3769    delete [] savedColumnScale_;
     3770  }
     3771  savedRowScale_ = NULL;
     3772  savedColumnScale_ = NULL;
    35843773}
    35853774/* Find a network subset.
Note: See TracChangeset for help on using the changeset viewer.