Changeset 919


Ignore:
Timestamp:
Feb 16, 2007 2:53:48 PM (14 years ago)
Author:
forrest
Message:

must update to match CoinUtils?/trunk

Location:
trunk/Clp/src
Files:
2 edited

Legend:

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

    r754 r919  
    247247      }
    248248      if (numberBasic>model->maximumBasic()) {
    249 #ifndef NDEBUG
     249#if 0 // ndef NDEBUG
    250250        printf("%d basic - should only be %d\n",
    251251               numberBasic,numberRows);
     
    317317        //fill
    318318        // Fill in counts so we can skip part of preProcess
    319         CoinZeroN ( numberInRow_, numberRows_ + 1 );
    320         CoinZeroN ( numberInColumn_, maximumColumnsExtra_ + 1 );
     319        int * numberInRow = numberInRow_.array();
     320        int * numberInColumn = numberInColumn_.array();
     321        CoinZeroN ( numberInRow, numberRows_ + 1 );
     322        CoinZeroN ( numberInColumn, maximumColumnsExtra_ + 1 );
     323        double * elementU = elementU_.array();
     324        int * indexRowU = indexRowU_.array();
     325        CoinBigIndex * startColumnU = startColumnU_.array();
    321326        for (i=0;i<numberRowBasic;i++) {
    322327          int iRow = pivotTemp[i];
    323           indexRowU_[i]=iRow;
    324           startColumnU_[i]=i;
    325           elementU_[i]=slackValue_;
    326           numberInRow_[iRow]=1;
    327           numberInColumn_[i]=1;
    328         }
    329         startColumnU_[numberRowBasic]=numberRowBasic;
     328          indexRowU[i]=iRow;
     329          startColumnU[i]=i;
     330          elementU[i]=slackValue_;
     331          numberInRow[iRow]=1;
     332          numberInColumn[i]=1;
     333        }
     334        startColumnU[numberRowBasic]=numberRowBasic;
    330335        // can change for gub so redo
    331336        numberColumnBasic = numberBasic-numberRowBasic;
     
    333338                          pivotTemp+numberRowBasic,
    334339                          numberColumnBasic,
    335                           indexRowU_,
    336                           startColumnU_+numberRowBasic,
    337                           numberInRow_,
    338                           numberInColumn_+numberRowBasic,
    339                           elementU_);
     340                          indexRowU_.array(),
     341                          startColumnU+numberRowBasic,
     342                          numberInRow,
     343                          numberInColumn+numberRowBasic,
     344                          elementU_.array());
    340345#if 0
    341346        {
    342347          printf("%d row basic, %d column basic\n",numberRowBasic,numberColumnBasic);
    343348          for (int i=0;i<numberElements;i++)
    344             printf("row %d col %d value %g\n",indexRowU_[i],indexColumnU_[i],
    345                    elementU_[i]);
     349            printf("row %d col %d value %g\n",indexRowU_.array()[i],indexColumnU_[i],
     350                   elementU_.array()[i]);
    346351        }
    347352#endif
     
    349354        numberBasic = numberRowBasic+numberColumnBasic;
    350355        if (numberBasic)
    351           numberElements = startColumnU_[numberBasic-1]
    352             +numberInColumn_[numberBasic-1];
     356          numberElements = startColumnU[numberBasic-1]
     357            +numberInColumn[numberBasic-1];
    353358        else
    354359          numberElements=0;
     
    377382        // as we do for network
    378383        matrix->generalExpanded(model,12,useNumberRows);
    379         int * permuteBack = permuteBack_;
    380         int * back = pivotColumnBack_;
    381         //int * pivotTemp = pivotColumn_;
     384        const int * permuteBack = permuteBack_.array();
     385        const int * back = pivotColumnBack_.array();
     386        //int * pivotTemp = pivotColumn_.array();
    382387        //ClpDisjointCopyN ( pivotVariable, numberRows , pivotTemp  );
    383388        // Redo pivot order
     
    397402          memset(saveList,0,((numberRows_+31)>>5)*sizeof(int));
    398403          for (i=numberRows_-numberSave;i<numberRows_;i++) {
    399             int k=pivotTemp[pivotColumn_[i]];
     404            int k=pivotTemp[pivotColumn_.array()[i]];
    400405            setDense(k);
    401406          }
     
    405410        // these arrays start off as copies of permute
    406411        // (and we could use permute_ instead of pivotColumn (not back though))
    407         ClpDisjointCopyN ( permute_, useNumberRows , pivotColumn_  );
    408         ClpDisjointCopyN ( permuteBack_, useNumberRows , pivotColumnBack_  );
     412        ClpDisjointCopyN ( permute_.array(), useNumberRows , pivotColumn_.array()  );
     413        ClpDisjointCopyN ( permuteBack_.array(), useNumberRows , pivotColumnBack_.array()  );
    409414#ifndef SLIM_CLP
    410415        if (networkMatrix) {
     
    414419            delete networkBasis_; // temp
    415420          networkBasis_ = new ClpNetworkBasis(model,numberRows_,
    416                                               pivotRegion_,
    417                                               permuteBack_,
    418                                               startColumnU_,
    419                                               numberInColumn_,
    420                                               indexRowU_,
    421                                               elementU_);
     421                                              pivotRegion_.array(),
     422                                              permuteBack_.array(),
     423                                              startColumnU_.array(),
     424                                              numberInColumn_.array(),
     425                                              indexRowU_.array(),
     426                                              elementU_.array());
    422427          // kill off arrays in ordinary factorization
    423428          if (!doCheck) {
     
    490495          pivotVariable[i]=-1;
    491496        // mark as basic or non basic
     497        const int * pivotColumn = pivotColumn_.array();
    492498        for (i=0;i<numberRows;i++) {
    493499          if (rowIsBasic[i]>=0) {
    494             if (pivotColumn_[numberBasic]>=0) {
    495               rowIsBasic[i]=pivotColumn_[numberBasic];
     500            if (pivotColumn[numberBasic]>=0) {
     501              rowIsBasic[i]=pivotColumn[numberBasic];
    496502            } else {
    497503              rowIsBasic[i]=-1;
     
    503509        for (i=0;i<numberColumns;i++) {
    504510          if (columnIsBasic[i]>=0) {
    505             if (pivotColumn_[numberBasic]>=0)
    506               columnIsBasic[i]=pivotColumn_[numberBasic];
     511            if (pivotColumn[numberBasic]>=0)
     512              columnIsBasic[i]=pivotColumn[numberBasic];
    507513            else
    508514              columnIsBasic[i]=-1;
     
    938944  }
    939945#endif
    940   int * permuteBack = pivotColumnBack_;
    941   if (!startRowL_||!numberInRow_) {
     946  int * numberInRow = numberInRow_.array();
     947  int * numberInColumn = numberInColumn_.array();
     948  int * permuteBack = pivotColumnBack_.array();
     949  int * indexRowU = indexRowU_.array();
     950  const CoinBigIndex * startColumnU = startColumnU_.array();
     951  const CoinBigIndex * startRowL = startRowL_.array();
     952  if (!startRowL||!numberInRow_.array()) {
    942953    int * temp = new int[numberRows_];
    943954    memset(temp,0,numberRows_*sizeof(int));
     
    947958      temp[i]++;
    948959      CoinBigIndex j;
    949       for (j=startColumnU_[i];j<startColumnU_[i]+numberInColumn_[i];j++) {
    950         int iRow=indexRowU_[j];
     960      for (j=startColumnU[i];j<startColumnU[i]+numberInColumn[i];j++) {
     961        int iRow=indexRowU[j];
    951962        temp[iRow]++;
    952963      }
    953964    }
     965    CoinBigIndex * startColumnL = startColumnL_.array();
     966    int * indexRowL = indexRowL_.array();
    954967    for (i=baseL_;i<baseL_+numberL_;i++) {
    955968      CoinBigIndex j;
    956       for (j=startColumnL_[i];j<startColumnL_[i+1];j++) {
    957         int iRow = indexRowL_[j];
     969      for (j=startColumnL[i];j<startColumnL[i+1];j++) {
     970        int iRow = indexRowL[j];
    958971        temp[iRow]++;
    959972      }
     
    968981    int i;
    969982    for (i=0;i<numberRows_;i++) {
    970       int number = startRowL_[i+1]-startRowL_[i]+numberInRow_[i]+1;
    971       //number = startRowL_[i+1]-startRowL_[i]+1;
    972       //number = numberInRow_[i]+1;
     983      int number = startRowL[i+1]-startRowL[i]+numberInRow[i]+1;
     984      //number = startRowL[i+1]-startRowL[i]+1;
     985      //number = numberInRow[i]+1;
    973986      int iPermute = permuteBack[i];
    974987      weights[iPermute]=number;
  • trunk/Clp/src/ClpSimplexDual.cpp

    r914 r919  
    39063906        //assert(numberDualInfeasibilitiesWithoutFree_==0);
    39073907
    3908         if (numberDualInfeasibilities_||situationChanged==2)
     3908        if (numberDualInfeasibilities_) {
     3909          if (numberPrimalInfeasibilities_||numberPivots)
     3910            problemStatus_=-1; // carry on as normal
     3911          else
     3912            problemStatus_=10; // try primal
     3913        } else if (situationChanged==2) {
    39093914          problemStatus_=-1; // carry on as normal
     3915        }
    39103916        situationChanged=0;
    39113917      } else {
     
    41134119    lower_[iSequence]=auxiliaryModel_->lowerRegion()[iSequence+numberRows_+numberColumns_];
    41144120    upper_[iSequence]=auxiliaryModel_->upperRegion()[iSequence+numberRows_+numberColumns_];
     4121    setFakeBound(iSequence,noFake);
    41154122    return;
    41164123  }
     
    50305037    case superBasic:
    50315038    case ClpSimplex::isFixed:
    5032       assert (bound==noFake);
     5039      //setFakeBound (iSequence, noFake);
    50335040      break;
    50345041    case atUpperBound:
     
    51385145          thetaUp = 0.0;
    51395146          bestAlphaDown = fabs(alpha);
    5140           bestAlphaUp = bestAlphaUp;
     5147          bestAlphaUp = bestAlphaDown;
    51415148          sequenceDown =iSequence2;
    51425149          sequenceUp = sequenceDown;
     
    53585365          thetaUp = 0.0;
    53595366          bestAlphaDown = fabs(alpha);
    5360           bestAlphaUp = bestAlphaUp;
     5367          bestAlphaUp = bestAlphaDown;
    53615368          sequenceDown =iSequence2;
    53625369          sequenceUp = sequenceDown;
Note: See TracChangeset for help on using the changeset viewer.