Changeset 454


Ignore:
Timestamp:
Sep 27, 2004 9:17:42 AM (15 years ago)
Author:
forrest
Message:

Fix Network code

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpFactorization.cpp

    r414 r454  
    1717const static bool doCheck=false;
    1818#endif
    19 
    2019//#############################################################################
    2120// Constructors / Destructor / Assignment
     
    158157#endif
    159158      // If network - still allow ordinary factorization first time for laziness
     159      if (networkMatrix)
     160        biasLU_=0; // All to U if network
    160161      int saveMaximumPivots = maximumPivots();
    161162      delete networkBasis_;
     
    273274          if (!doCheck) {
    274275            gutsOfDestructor();
     276            // but make sure numberRows_ set
     277            numberRows_ = model->numberRows();
    275278            status_=0;
    276279#if 0
     
    542545#ifdef CHECK_NETWORK
    543546    CoinIndexedVector * save = new CoinIndexedVector(*regionSparse2);
     547    double * check = new double[numberRows_];
    544548    int returnCode = CoinFactorization::updateColumnFT(regionSparse,
    545549                                                       regionSparse2);
    546     networkBasis_->updateColumn(regionSparse,save);
     550    networkBasis_->updateColumn(regionSparse,save,-1);
    547551    int i;
    548552    double * array = regionSparse2->denseVector();
     553    int * indices = regionSparse2->getIndices();
     554    int n=regionSparse2->getNumElements();
     555    memset(check,0,numberRows_*sizeof(double));
    549556    double * array2 = save->denseVector();
    550     for (i=0;i<numberRows_;i++) {
    551       double value1 = array[i];
    552       double value2 = array2[i];
    553       assert (value1==value2);
     557    int * indices2 = save->getIndices();
     558    int n2=save->getNumElements();
     559    assert (n==n2);
     560    if (save->packedMode()) {
     561      for (i=0;i<n;i++) {
     562        check[indices[i]]=array[i];
     563      }
     564      for (i=0;i<n;i++) {
     565        double value2 = array2[i];
     566        assert (check[indices2[i]]==value2);
     567      }
     568    } else {
     569      for (i=0;i<numberRows_;i++) {
     570        double value1 = array[i];
     571        double value2 = array2[i];
     572        assert (value1==value2);
     573      }
    554574    }
    555575    delete save;
     576    delete [] check;
    556577    return returnCode;
    557578#else
     
    585606#ifdef CHECK_NETWORK
    586607    CoinIndexedVector * save = new CoinIndexedVector(*regionSparse2);
     608    double * check = new double[numberRows_];
    587609    int returnCode = CoinFactorization::updateColumn(regionSparse,
    588610                                                     regionSparse2,
    589611                                                     noPermute);
    590     networkBasis_->updateColumn(regionSparse,save);
     612    networkBasis_->updateColumn(regionSparse,save,-1);
    591613    int i;
    592614    double * array = regionSparse2->denseVector();
     615    int * indices = regionSparse2->getIndices();
     616    int n=regionSparse2->getNumElements();
     617    memset(check,0,numberRows_*sizeof(double));
    593618    double * array2 = save->denseVector();
    594     for (i=0;i<numberRows_;i++) {
    595       double value1 = array[i];
    596       double value2 = array2[i];
    597       assert (value1==value2);
     619    int * indices2 = save->getIndices();
     620    int n2=save->getNumElements();
     621    assert (n==n2);
     622    if (save->packedMode()) {
     623      for (i=0;i<n;i++) {
     624        check[indices[i]]=array[i];
     625      }
     626      for (i=0;i<n;i++) {
     627        double value2 = array2[i];
     628        assert (check[indices2[i]]==value2);
     629      }
     630    } else {
     631      for (i=0;i<numberRows_;i++) {
     632        double value1 = array[i];
     633        double value2 = array2[i];
     634        assert (value1==value2);
     635      }
    598636    }
    599637    delete save;
     638    delete [] check;
    600639    return returnCode;
    601640#else
     
    620659  } else {
    621660#ifdef CHECK_NETWORK
    622       CoinIndexedVector * save = new CoinIndexedVector(*regionSparse2);
    623       int returnCode = CoinFactorization::updateColumnTranspose(regionSparse,
    624                                                                 regionSparse2);
    625       networkBasis_->updateColumnTranspose(regionSparse,save);
    626       int i;
    627       double * array = regionSparse2->denseVector();
    628       double * array2 = save->denseVector();
     661    CoinIndexedVector * save = new CoinIndexedVector(*regionSparse2);
     662    double * check = new double[numberRows_];
     663    int returnCode = CoinFactorization::updateColumnTranspose(regionSparse,
     664                                                              regionSparse2);
     665    networkBasis_->updateColumnTranspose(regionSparse,save);
     666    int i;
     667    double * array = regionSparse2->denseVector();
     668    int * indices = regionSparse2->getIndices();
     669    int n=regionSparse2->getNumElements();
     670    memset(check,0,numberRows_*sizeof(double));
     671    double * array2 = save->denseVector();
     672    int * indices2 = save->getIndices();
     673    int n2=save->getNumElements();
     674    assert (n==n2);
     675    if (save->packedMode()) {
     676      for (i=0;i<n;i++) {
     677        check[indices[i]]=array[i];
     678      }
     679      for (i=0;i<n;i++) {
     680        double value2 = array2[i];
     681        assert (check[indices2[i]]==value2);
     682      }
     683    } else {
    629684      for (i=0;i<numberRows_;i++) {
    630685        double value1 = array[i];
     
    632687        assert (value1==value2);
    633688      }
    634       delete save;
    635       return returnCode;
     689    }
     690    delete save;
     691    delete [] check;
     692    return returnCode;
    636693#else
    637       return networkBasis_->updateColumnTranspose(regionSparse,regionSparse2);
     694    return networkBasis_->updateColumnTranspose(regionSparse,regionSparse2);
    638695#endif
    639696  }
     
    666723    return false;
    667724}
     725// Get weighted row list
     726void
     727ClpFactorization::getWeights(int * weights) const
     728{
     729  if (networkBasis_) {
     730    // Network - just unit
     731    for (int i=0;i<numberRows_;i++)
     732      weights[i]=1;
     733    return;
     734  }
     735  int * permuteBack = pivotColumnBack_;
     736  if (!startRowL_||!numberInRow_) {
     737    int * temp = new int[numberRows_];
     738    memset(temp,0,numberRows_*sizeof(int));
     739    int i;
     740    for (i=0;i<numberRows_;i++) {
     741      // one for pivot
     742      temp[i]++;
     743      CoinBigIndex j;
     744      for (j=startColumnU_[i];j<startColumnU_[i]+numberInColumn_[i];j++) {
     745        int iRow=indexRowU_[j];
     746        temp[iRow]++;
     747      }
     748    }
     749    for (i=baseL_;i<baseL_+numberL_;i++) {
     750      CoinBigIndex j;
     751      for (j=startColumnL_[i];j<startColumnL_[i+1];j++) {
     752        int iRow = indexRowL_[j];
     753        temp[iRow]++;
     754      }
     755    }
     756    for (i=0;i<numberRows_;i++) {
     757      int number = temp[i];
     758      int iPermute = permuteBack[i];
     759      weights[iPermute]=number;
     760    }
     761    delete [] temp;
     762  } else {
     763    int i;
     764    for (i=0;i<numberRows_;i++) {
     765      int number = startRowL_[i+1]-startRowL_[i]+numberInRow_[i]+1;
     766      //number = startRowL_[i+1]-startRowL_[i]+1;
     767      //number = numberInRow_[i]+1;
     768      int iPermute = permuteBack[i];
     769      weights[iPermute]=number;
     770    }
     771  }
     772}
  • trunk/Makefile.Clp

    r447 r454  
    66# highest level of optimization the compiler supports. If want something in
    77# between then specify the exact level you want, e.g., -O1 or -O2
    8 #OptLevel := -g
     8OptLevel := -g
    99OptLevel := -O1
    1010
  • trunk/include/ClpFactorization.hpp

    r440 r454  
    101101  bool inline networkBasis() const
    102102  { return (networkBasis_!=NULL);};
     103  /// Fills weighted row list
     104  void getWeights(int * weights) const;
    103105  //@}
    104106
Note: See TracChangeset for help on using the changeset viewer.