Changeset 918 for branches


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

for messages

Location:
branches/devel/Clp/src
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • branches/devel/Clp/src/CbcOrClpParam.cpp

    r904 r918  
    14691469 is initialized to 'default.mps'."
    14701470     );
     1471#ifdef COIN_HAS_CBC
     1472  parameters[numberParameters++]=
     1473    CbcOrClpParam("extra1","Extra integer parameter 1",
     1474                  -1,INT_MAX,EXTRA1,false);
     1475  parameters[numberParameters-1].setIntValue(-1);
     1476  parameters[numberParameters++]=
     1477    CbcOrClpParam("extra2","Extra integer parameter 2",
     1478                  -1,INT_MAX,EXTRA2,false);
     1479  parameters[numberParameters-1].setIntValue(-1);
     1480  parameters[numberParameters++]=
     1481    CbcOrClpParam("extra3","Extra integer parameter 3",
     1482                  -1,INT_MAX,EXTRA3,false);
     1483  parameters[numberParameters-1].setIntValue(-1);
     1484  parameters[numberParameters++]=
     1485    CbcOrClpParam("extra4","Extra integer parameter 4",
     1486                  -1,INT_MAX,EXTRA4,false);
     1487  parameters[numberParameters-1].setIntValue(-1);
     1488#endif
    14711489#ifdef COIN_HAS_CLP
    14721490  parameters[numberParameters++]=
  • branches/devel/Clp/src/CbcOrClpParam.hpp

    r904 r918  
    6464    STRONGBRANCHING=151,CUTDEPTH, MAXNODES,NUMBERBEFORE,NUMBERANALYZE,
    6565    NUMBERMINI,MIPOPTIONS,MOREMIPOPTIONS,MAXHOTITS,FPUMPITS,MAXSOLS,
    66     FPUMPTUNE,TESTOSI,
     66    FPUMPTUNE,TESTOSI,EXTRA1,EXTRA2,EXTRA3,EXTRA4,
    6767#ifdef COIN_HAS_CBC
    6868    LOGLEVEL ,
  • branches/devel/Clp/src/ClpFactorization.cpp

    r854 r918  
    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;
  • branches/devel/Clp/src/ClpMessage.cpp

    r754 r918  
    122122     addMessage(message->internalNumber,oneMessage);
    123123     message ++;
    124 }
     124  }
     125  // Put into compact form
     126  toCompact();
    125127
    126128  // now override any language ones
  • branches/devel/Clp/src/ClpModel.cpp

    r888 r918  
    4141
    4242//#############################################################################
    43 
    44 ClpModel::ClpModel () :
     43ClpModel::ClpModel (bool emptyMessages) :
    4544
    4645  optimizationDirection_(1),
     
    102101  handler_->setLogLevel(1);
    103102  eventHandler_ = new ClpEventHandler();
    104   messages_ = ClpMessage();
    105   coinMessages_ = CoinMessage();
     103  if (!emptyMessages) {
     104    messages_ = ClpMessage();
     105    coinMessages_ = CoinMessage();
     106  }
    106107  CoinSeedRandom(1234567);
    107108}
  • branches/devel/Clp/src/ClpModel.hpp

    r800 r918  
    4646  //@{
    4747    /// Default constructor
    48     ClpModel (  );
     48    ClpModel (bool emptyMessages=false  );
    4949
    5050  /** Copy constructor. May scale depending on mode
  • branches/devel/Clp/src/ClpPackedMatrix.cpp

    r854 r918  
    26782678  // Say no gaps
    26792679  flags_ &= ~2;
    2680   if (check==14) {
     2680  if (check==14||check==10) {
    26812681    for (iColumn=0;iColumn<numberColumns;iColumn++) {
    26822682      CoinBigIndex start = columnStart[iColumn];
     
    26892689    return true;
    26902690  }
    2691   assert (check==15);
    2692   int * mark = new int [numberRows];
    2693   int i;
    2694   for (i=0;i<numberRows;i++)
    2695     mark[i]=-1;
    2696   for (iColumn=0;iColumn<numberColumns;iColumn++) {
    2697     CoinBigIndex j;
    2698     CoinBigIndex start = columnStart[iColumn];
    2699     CoinBigIndex end = start + columnLength[iColumn];
    2700     if (end!=columnStart[iColumn+1])
    2701       flags_ |= 2;
    2702     for (j=start;j<end;j++) {
    2703       double value = fabs(elementByColumn[j]);
    2704       int iRow = row[j];
    2705       if (iRow<0||iRow>=numberRows) {
     2691  assert (check==15||check==11);
     2692  if (check==15) {
     2693    int * mark = new int [numberRows];
     2694    int i;
     2695    for (i=0;i<numberRows;i++)
     2696      mark[i]=-1;
     2697    for (iColumn=0;iColumn<numberColumns;iColumn++) {
     2698      CoinBigIndex j;
     2699      CoinBigIndex start = columnStart[iColumn];
     2700      CoinBigIndex end = start + columnLength[iColumn];
     2701      if (end!=columnStart[iColumn+1])
     2702        flags_ |= 2;
     2703      for (j=start;j<end;j++) {
     2704        double value = fabs(elementByColumn[j]);
     2705        int iRow = row[j];
     2706        if (iRow<0||iRow>=numberRows) {
    27062707#ifndef COIN_BIG_INDEX
    2707         printf("Out of range %d %d %d %g\n",iColumn,j,row[j],elementByColumn[j]);
     2708          printf("Out of range %d %d %d %g\n",iColumn,j,row[j],elementByColumn[j]);
    27082709#elif COIN_BIG_INDEX==1
    2709         printf("Out of range %d %ld %d %g\n",iColumn,j,row[j],elementByColumn[j]);
     2710          printf("Out of range %d %ld %d %g\n",iColumn,j,row[j],elementByColumn[j]);
    27102711#else
    2711         printf("Out of range %d %lld %d %g\n",iColumn,j,row[j],elementByColumn[j]);
    2712 #endif
    2713         return false;
    2714       }
    2715       if (mark[iRow]==-1) {
    2716         mark[iRow]=j;
    2717       } else {
    2718         // duplicate
    2719         numberDuplicate++;
    2720       }
    2721       //printf("%d %d %d %g\n",iColumn,j,row[j],elementByColumn[j]);
    2722       if (!value)
    2723         flags_ |= 1; // there are zero elements
    2724       if (value<smallest) {
    2725         numberSmall++;
    2726       } else if (!(value<=largest)) {
    2727         numberLarge++;
    2728         if (firstBadColumn<0) {
    2729           firstBadColumn=iColumn;
    2730           firstBadRow=row[j];
    2731           firstBadElement=elementByColumn[j];
    2732         }
    2733       }
    2734     }
    2735     //clear mark
    2736     for (j=columnStart[iColumn];
    2737          j<columnStart[iColumn]+columnLength[iColumn];j++) {
    2738       int iRow = row[j];
    2739       mark[iRow]=-1;
    2740     }
    2741   }
    2742   delete [] mark;
     2712          printf("Out of range %d %lld %d %g\n",iColumn,j,row[j],elementByColumn[j]);
     2713#endif
     2714          return false;
     2715        }
     2716        if (mark[iRow]==-1) {
     2717          mark[iRow]=j;
     2718        } else {
     2719          // duplicate
     2720          numberDuplicate++;
     2721        }
     2722        //printf("%d %d %d %g\n",iColumn,j,row[j],elementByColumn[j]);
     2723        if (!value)
     2724          flags_ |= 1; // there are zero elements
     2725        if (value<smallest) {
     2726          numberSmall++;
     2727        } else if (!(value<=largest)) {
     2728          numberLarge++;
     2729          if (firstBadColumn<0) {
     2730            firstBadColumn=iColumn;
     2731            firstBadRow=row[j];
     2732            firstBadElement=elementByColumn[j];
     2733          }
     2734        }
     2735      }
     2736      //clear mark
     2737      for (j=columnStart[iColumn];
     2738           j<columnStart[iColumn]+columnLength[iColumn];j++) {
     2739        int iRow = row[j];
     2740        mark[iRow]=-1;
     2741      }
     2742    }
     2743    delete [] mark;
     2744  } else {
     2745    // just check for out of range - not for duplicates
     2746    for (iColumn=0;iColumn<numberColumns;iColumn++) {
     2747      CoinBigIndex j;
     2748      CoinBigIndex start = columnStart[iColumn];
     2749      CoinBigIndex end = start + columnLength[iColumn];
     2750      if (end!=columnStart[iColumn+1])
     2751        flags_ |= 2;
     2752      for (j=start;j<end;j++) {
     2753        double value = fabs(elementByColumn[j]);
     2754        int iRow = row[j];
     2755        if (iRow<0||iRow>=numberRows) {
     2756#ifndef COIN_BIG_INDEX
     2757          printf("Out of range %d %d %d %g\n",iColumn,j,row[j],elementByColumn[j]);
     2758#elif COIN_BIG_INDEX==1
     2759          printf("Out of range %d %ld %d %g\n",iColumn,j,row[j],elementByColumn[j]);
     2760#else
     2761          printf("Out of range %d %lld %d %g\n",iColumn,j,row[j],elementByColumn[j]);
     2762#endif
     2763          return false;
     2764        }
     2765        if (!value)
     2766          flags_ |= 1; // there are zero elements
     2767        if (value<smallest) {
     2768          numberSmall++;
     2769        } else if (!(value<=largest)) {
     2770          numberLarge++;
     2771          if (firstBadColumn<0) {
     2772            firstBadColumn=iColumn;
     2773            firstBadRow=iRow;
     2774            firstBadElement=value;
     2775          }
     2776        }
     2777      }
     2778    }
     2779  }
    27432780  if (numberLarge) {
    27442781    model->messageHandler()->message(CLP_BAD_MATRIX,model->messages())
  • branches/devel/Clp/src/ClpSimplex.cpp

    r910 r918  
    3535//#############################################################################
    3636
    37 ClpSimplex::ClpSimplex () :
     37ClpSimplex::ClpSimplex (bool emptyMessages) :
    3838
    39   ClpModel(),
     39  ClpModel(emptyMessages),
    4040  columnPrimalInfeasibility_(0.0),
    4141  rowPrimalInfeasibility_(0.0),
     
    132132  saveStatus_=NULL;
    133133  // get an empty factorization so we can set tolerances etc
    134   factorization_ = new ClpFactorization();
     134  getEmptyFactorization();
    135135  // Say sparse
    136136  factorization_->sparseThreshold(1);
     
    244244  saveStatus_=NULL;
    245245  // get an empty factorization so we can set tolerances etc
    246   factorization_ = new ClpFactorization();
     246  getEmptyFactorization();
    247247  // say Steepest pricing
    248248  dualRowPivot_ = new ClpDualRowSteepest();
     
    329329ClpSimplex::~ClpSimplex ()
    330330{
     331  setPersistenceFlag(0);
    331332  gutsOfDelete(0);
    332333  delete nonLinearCost_;
     
    17921793  saveStatus_=NULL;
    17931794  // get an empty factorization so we can set tolerances etc
    1794   factorization_ = new ClpFactorization();
     1795  getEmptyFactorization();
    17951796  // say Steepest pricing
    17961797  dualRowPivot_ = new ClpDualRowSteepest();
     
    18891890  }
    18901891  if (rhs.factorization_) {
     1892    delete factorization_;
    18911893    factorization_ = new ClpFactorization(*rhs.factorization_);
    18921894  } else {
     
    20002002  }
    20012003  int i;
    2002   for (i=0;i<6;i++) {
    2003     delete rowArray_[i];
    2004     rowArray_[i]=NULL;
    2005     delete columnArray_[i];
    2006     columnArray_[i]=NULL;
     2004  if ((specialOptions_&65536)==0) {
     2005    for (i=0;i<6;i++) {
     2006      delete rowArray_[i];
     2007      rowArray_[i]=NULL;
     2008      delete columnArray_[i];
     2009      columnArray_[i]=NULL;
     2010    }
    20072011  }
    20082012  delete rowCopy_;
     
    20142018    delete auxiliaryModel_;
    20152019    auxiliaryModel_ = NULL;
    2016     delete factorization_;
    2017     factorization_ = NULL;
     2020    setEmptyFactorization();
    20182021    delete [] pivotVariable_;
    20192022    pivotVariable_=NULL;
     
    26112614    if (oldMatrix)
    26122615      checkType = 14;
     2616    if ((specialOptions_&0x1000000)!=0)
     2617      checkType -= 4; // don't check for duplicates
    26132618    if (!matrix_->allElementsInRange(this,smallElement_,1.0e20,checkType)) {
    26142619      problemStatus_=4;
     
    26222627    }
    26232628    // do scaling if needed
    2624     if (!oldMatrix) {
     2629    if (!oldMatrix&&scalingFlag_<0) {
    26252630      if (scalingFlag_<0&&rowScale_) {
    26262631        if (handler_->logLevel()>0)
     
    33913396      *********************************************************/
    33923397      for (iRow=0;iRow<4;iRow++) {
    3393         delete rowArray_[iRow];
    3394         rowArray_[iRow]=new CoinIndexedVector();
    33953398        int length =numberRows2+factorization_->maximumPivots();
    33963399        if (iRow==3||objective_->type()>1)
    33973400          length += numberColumns_;
     3401        if ((specialOptions_&65536)==0||!rowArray_[iRow]) {
     3402          delete rowArray_[iRow];
     3403          rowArray_[iRow]=new CoinIndexedVector();
     3404        }
    33983405        rowArray_[iRow]->reserve(length);
    33993406      }
    34003407     
    34013408      for (iColumn=0;iColumn<2;iColumn++) {
    3402         delete columnArray_[iColumn];
    3403         columnArray_[iColumn]=new CoinIndexedVector();
     3409        if ((specialOptions_&65536)==0||!columnArray_[iColumn]) {
     3410          delete columnArray_[iColumn];
     3411          columnArray_[iColumn]=new CoinIndexedVector();
     3412        }
    34043413        if (!iColumn)
    34053414          columnArray_[iColumn]->reserve(numberColumns_);
     
    34343443        if (iRow==3||objective_->type()>1)
    34353444          length += numberColumns_;
    3436         assert(rowArray_[iRow]->capacity()==length);
     3445        assert(rowArray_[iRow]->capacity()>=length);
    34373446        rowArray_[iRow]->checkClear();
    34383447#endif
     
    34453454        if (iColumn)
    34463455          length=CoinMax(numberRows2,numberColumns_);
    3447         assert(columnArray_[iColumn]->capacity()==length);
     3456        assert(columnArray_[iColumn]->capacity()>=length);
    34483457        columnArray_[iColumn]->checkClear();
    34493458#endif
     
    52925301    }
    52935302    // get an empty factorization so we can set tolerances etc
    5294     factorization_ = new ClpFactorization();
     5303    getEmptyFactorization();
    52955304    // Say sparse
    52965305    factorization_->sparseThreshold(1);
     
    86958704  if (options>=0) {
    86968705    createRim(63,true,0);
    8697     auxiliaryModel_ = new ClpSimplex();
     8706    auxiliaryModel_ = new ClpSimplex(true);
    86988707    auxiliaryModel_->specialOptions_=options;
    86998708    int i;
     
    89578966  }
    89588967}
     8968// Gets clean and emptyish factorization
     8969ClpFactorization *
     8970ClpSimplex::getEmptyFactorization()
     8971{
     8972  if ((specialOptions_&65536)==0) {
     8973    assert (!factorization_);
     8974    factorization_=new ClpFactorization();
     8975  } else if (!factorization_) {
     8976    factorization_=new ClpFactorization();
     8977    factorization_->setPersistenceFlag(1);
     8978  }
     8979  return factorization_;
     8980}
     8981// May delete or may make clean and emptyish factorization
     8982void
     8983ClpSimplex::setEmptyFactorization()
     8984{
     8985  if (factorization_) {
     8986    factorization_->cleanUp();
     8987    if ((specialOptions_&65536)==0) {
     8988      delete factorization_;
     8989      factorization_=NULL;
     8990    } else if (factorization_) {
     8991      factorization_->almostDestructor();
     8992    }
     8993  }
     8994}
     8995/* Array persistence flag
     8996   If 0 then as now (delete/new)
     8997   1 then only do arrays if bigger needed
     8998   2 as 1 but give a bit extra if bigger needed
     8999*/
     9000void
     9001ClpSimplex::setPersistenceFlag(int value)
     9002{
     9003  if (value) {
     9004    specialOptions_|=65536;
     9005  } else {
     9006    specialOptions_&=~65536;
     9007  }
     9008  if (factorization_)
     9009    factorization_->setPersistenceFlag(value);
     9010}
    89599011// Create C++ lines to get to current state
    89609012void
  • branches/devel/Clp/src/ClpSimplex.hpp

    r911 r918  
    7676  //@{
    7777  /// Default constructor
    78     ClpSimplex (  );
     78    ClpSimplex (bool emptyMessages = false  );
    7979
    8080  /** Copy constructor. May scale depending on mode
     
    107107      Only to be used with mini constructor */
    108108  void originalModel(ClpSimplex * miniModel);
     109  /** Array persistence flag
     110      If 0 then as now (delete/new)
     111      1 then only do arrays if bigger needed
     112      2 as 1 but give a bit extra if bigger needed
     113  */
     114  void setPersistenceFlag(int value);
    109115  /**
    110116     If you are re-using the same matrix again and again then the setup time
     
    969975      16384 - In fast dual (so we can switch off things)
    970976      32678 - called from Osi
     977      65356 - keep arrays around as much as possible
    971978      NOTE - many applications can call Clp but there may be some short cuts
    972979             which are taken which are not guaranteed safe from all applications.
     
    983990  { return specialOptions_;};
    984991  void setSpecialOptions(unsigned int value);
     992  /// Gets clean and emptyish factorization
     993  ClpFactorization * getEmptyFactorization();
     994  /// May delete or may make clean and emptyish factorization
     995  void setEmptyFactorization();
    985996  //@}
    986997
  • branches/devel/Clp/src/ClpSimplexDual.cpp

    r908 r918  
    39593959        dualTolerance_=saveTolerance;
    39603960        //assert(numberDualInfeasibilitiesWithoutFree_==0);
    3961 
    3962         if (numberDualInfeasibilities_||situationChanged==2)
     3961        if (numberDualInfeasibilities_) {
     3962          if (numberPrimalInfeasibilities_||numberPivots)
     3963            problemStatus_=-1; // carry on as normal
     3964          else
     3965            problemStatus_=10; // try primal
     3966        } else if (situationChanged==2) {
    39633967          problemStatus_=-1; // carry on as normal
     3968        }
    39643969        situationChanged=0;
    39653970      } else {
     
    41994204ClpSimplexDual::originalBound( int iSequence)
    42004205{
    4201   if (getFakeBound(iSequence)!=noFake)
     4206  if (getFakeBound(iSequence)!=noFake) {
    42024207    numberFake_--;;
    4203   if (auxiliaryModel_) {
    4204     // just copy back
    4205     lower_[iSequence]=auxiliaryModel_->lowerRegion()[iSequence+numberRows_+numberColumns_];
    4206     upper_[iSequence]=auxiliaryModel_->upperRegion()[iSequence+numberRows_+numberColumns_];
    4207   setFakeBound(iSequence,noFake);
    4208     return;
    4209   }
    4210   if (iSequence>=numberColumns_) {
    4211     // rows
    4212     int iRow = iSequence-numberColumns_;
    4213     rowLowerWork_[iRow]=rowLower_[iRow];
    4214     rowUpperWork_[iRow]=rowUpper_[iRow];
    4215     if (rowScale_) {
    4216       if (rowLowerWork_[iRow]>-1.0e50)
    4217         rowLowerWork_[iRow] *= rowScale_[iRow]*rhsScale_;
    4218       if (rowUpperWork_[iRow]<1.0e50)
    4219         rowUpperWork_[iRow] *= rowScale_[iRow]*rhsScale_;
    4220     } else if (rhsScale_!=1.0) {
    4221       if (rowLowerWork_[iRow]>-1.0e50)
    4222         rowLowerWork_[iRow] *= rhsScale_;
    4223       if (rowUpperWork_[iRow]<1.0e50)
    4224         rowUpperWork_[iRow] *= rhsScale_;
    4225     }
    4226   } else {
    4227     // columns
    4228     columnLowerWork_[iSequence]=columnLower_[iSequence];
    4229     columnUpperWork_[iSequence]=columnUpper_[iSequence];
    4230     if (rowScale_) {
    4231       double multiplier = 1.0/columnScale_[iSequence];
    4232       if (columnLowerWork_[iSequence]>-1.0e50)
    4233         columnLowerWork_[iSequence] *= multiplier*rhsScale_;
    4234       if (columnUpperWork_[iSequence]<1.0e50)
    4235         columnUpperWork_[iSequence] *= multiplier*rhsScale_;
    4236     } else if (rhsScale_!=1.0) {
    4237       if (columnLowerWork_[iSequence]>-1.0e50)
    4238         columnLowerWork_[iSequence] *= rhsScale_;
    4239       if (columnUpperWork_[iSequence]<1.0e50)
    4240         columnUpperWork_[iSequence] *= rhsScale_;
    4241     }
    4242   }
    4243   setFakeBound(iSequence,noFake);
     4208    setFakeBound(iSequence,noFake);
     4209    if (auxiliaryModel_) {
     4210      // just copy back
     4211      lower_[iSequence]=auxiliaryModel_->lowerRegion()[iSequence+numberRows_+numberColumns_];
     4212      upper_[iSequence]=auxiliaryModel_->upperRegion()[iSequence+numberRows_+numberColumns_];
     4213      return;
     4214    }
     4215    if (iSequence>=numberColumns_) {
     4216      // rows
     4217      int iRow = iSequence-numberColumns_;
     4218      rowLowerWork_[iRow]=rowLower_[iRow];
     4219      rowUpperWork_[iRow]=rowUpper_[iRow];
     4220      if (rowScale_) {
     4221        if (rowLowerWork_[iRow]>-1.0e50)
     4222          rowLowerWork_[iRow] *= rowScale_[iRow]*rhsScale_;
     4223        if (rowUpperWork_[iRow]<1.0e50)
     4224          rowUpperWork_[iRow] *= rowScale_[iRow]*rhsScale_;
     4225      } else if (rhsScale_!=1.0) {
     4226        if (rowLowerWork_[iRow]>-1.0e50)
     4227          rowLowerWork_[iRow] *= rhsScale_;
     4228        if (rowUpperWork_[iRow]<1.0e50)
     4229          rowUpperWork_[iRow] *= rhsScale_;
     4230      }
     4231    } else {
     4232      // columns
     4233      columnLowerWork_[iSequence]=columnLower_[iSequence];
     4234      columnUpperWork_[iSequence]=columnUpper_[iSequence];
     4235      if (rowScale_) {
     4236        double multiplier = 1.0/columnScale_[iSequence];
     4237        if (columnLowerWork_[iSequence]>-1.0e50)
     4238          columnLowerWork_[iSequence] *= multiplier*rhsScale_;
     4239        if (columnUpperWork_[iSequence]<1.0e50)
     4240          columnUpperWork_[iSequence] *= multiplier*rhsScale_;
     4241      } else if (rhsScale_!=1.0) {
     4242        if (columnLowerWork_[iSequence]>-1.0e50)
     4243          columnLowerWork_[iSequence] *= rhsScale_;
     4244        if (columnUpperWork_[iSequence]<1.0e50)
     4245          columnUpperWork_[iSequence] *= rhsScale_;
     4246      }
     4247    }
     4248  }
    42444249}
    42454250/* As changeBounds but just changes new bounds for a single variable.
     
    42604265  lower_[iSequence] = oldLower;
    42614266  upper_[iSequence] = oldUpper;
    4262   if (getFakeBound(iSequence)!=noFake)
    4263     numberFake_--;;
     4267  assert (getFakeBound(iSequence)==noFake);
     4268  //if (getFakeBound(iSequence)!=noFake)
     4269  //numberFake_--;;
    42644270  if (value==oldLower) {
    42654271    if (upperValue > oldLower + dualBound_) {
     
    51235129    case superBasic:
    51245130    case ClpSimplex::isFixed:
    5125       assert (bound==noFake);
     5131      //setFakeBound (iSequence, noFake);
    51265132      break;
    51275133    case atUpperBound:
     
    52315237          thetaUp = 0.0;
    52325238          bestAlphaDown = fabs(alpha);
    5233           bestAlphaUp = bestAlphaUp;
     5239          bestAlphaUp = bestAlphaDown;
    52345240          sequenceDown =iSequence2;
    52355241          sequenceUp = sequenceDown;
     
    54515457          thetaUp = 0.0;
    54525458          bestAlphaDown = fabs(alpha);
    5453           bestAlphaUp = bestAlphaUp;
     5459          bestAlphaUp = bestAlphaDown;
    54545460          sequenceDown =iSequence2;
    54555461          sequenceUp = sequenceDown;
  • branches/devel/Clp/src/Makefile.in

    r837 r918  
    210210abs_lib_dir = @abs_lib_dir@
    211211abs_source_dir = @abs_source_dir@
     212ac_c_preproc_warn_flag = @ac_c_preproc_warn_flag@
    212213ac_ct_AR = @ac_ct_AR@
    213214ac_ct_CC = @ac_ct_CC@
     
    216217ac_ct_RANLIB = @ac_ct_RANLIB@
    217218ac_ct_STRIP = @ac_ct_STRIP@
     219ac_cxx_preproc_warn_flag = @ac_cxx_preproc_warn_flag@
    218220am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
    219221am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
Note: See TracChangeset for help on using the changeset viewer.